Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2011, 2014 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 Lars Vogel (Lars.Vogel@gmail.com) - Bug 331690 /
  
  
  package org.eclipse.e4.ui.workbench.addons.minmax;
  
  import java.util.Arrays;
  import java.util.List;
  import  org.eclipse.e4.core.contexts.IEclipseContext;
  import  org.eclipse.e4.core.di.annotations.Optional;
  import  org.eclipse.e4.ui.di.UIEventTopic;
  import  org.eclipse.e4.ui.model.application.MAddon;
  import  org.eclipse.e4.ui.model.application.ui.MUIElement;
  import  org.eclipse.e4.ui.model.application.ui.SideValue;
  import  org.eclipse.e4.ui.model.application.ui.advanced.MArea;
  import  org.eclipse.e4.ui.model.application.ui.advanced.MPerspective;
  import  org.eclipse.e4.ui.model.application.ui.advanced.MPerspectiveStack;
  import  org.eclipse.e4.ui.model.application.ui.advanced.MPlaceholder;
  import  org.eclipse.e4.ui.model.application.ui.basic.MPartStack;
  import  org.eclipse.e4.ui.model.application.ui.basic.MTrimBar;
  import  org.eclipse.e4.ui.model.application.ui.basic.MTrimmedWindow;
  import  org.eclipse.e4.ui.model.application.ui.basic.MWindow;
  import  org.eclipse.e4.ui.model.application.ui.menu.MToolControl;
  import  org.eclipse.e4.ui.model.application.ui.menu.impl.MenuFactoryImpl;
  import  org.eclipse.e4.ui.workbench.IPresentationEngine;
  import  org.eclipse.e4.ui.workbench.UIEvents;
  import  org.eclipse.e4.ui.workbench.UIEvents.EventTags;
  import  org.eclipse.e4.ui.workbench.modeling.EModelService;
  import  org.eclipse.e4.ui.workbench.modeling.EPartService;
  import  org.eclipse.swt.custom.CTabFolder;
  import  org.eclipse.swt.custom.CTabFolder2Adapter;
  import  org.eclipse.swt.custom.CTabFolderEvent;
  import  org.eclipse.swt.events.MouseEvent;
  import  org.eclipse.swt.events.MouseListener;
  import  org.eclipse.swt.graphics.Rectangle;
  import  org.eclipse.swt.widgets.Control;
  import  org.eclipse.swt.widgets.Shell;
Workbench addon that provides methods to minimize, maximize and restore parts in the window
  
  public class MinMaxAddon {

The identifier for the shared area in the Eclipse Platform. This value should be identical to the value defined in org.eclipse.ui.IPageLayout.ID_EDITOR_AREA.
  
  	private static final String ID_EDITOR_AREA = "org.eclipse.ui.editorss"//$NON-NLS-1$
  
  	private static final String GLOBAL_CACHE_ID = "Global"//$NON-NLS-1$
  
  	static String ID_SUFFIX = "(minimized)"//$NON-NLS-1$
  
  	// tags representing the min/max state (h
  	private static String MINIMIZED = IPresentationEngine.MINIMIZED;
  	private static String MAXIMIZED = IPresentationEngine.MAXIMIZED;
  	private static String MINIMIZED_BY_ZOOM = IPresentationEngine.MINIMIZED_BY_ZOOM;
  
  	@Inject
  
  	@Inject
  	EModelService modelService;
  
  	@Inject
  	private IEclipseContext context;
  
  	@Inject
  	private EPartService partService;
  
  	// Allow 'local' changes to the tags
  	private boolean ignoreTagChanges = false;
  
  	@Inject
  	MAddon minMaxAddon;
  
  	private CTabFolder2Adapter CTFButtonListener = new CTabFolder2Adapter() {
  		private MUIElement getElementToChange(CTabFolderEvent event) {
  			CTabFolder ctf = (CTabFolder) event.widget;
  			MUIElement element = (MUIElement) ctf.getData(.);
  			if (element instanceof MArea)
  				return element.getCurSharedRef();
  
  			MUIElement parentElement = element.getParent();
 			while (parentElement != null && !(parentElement instanceof MArea))
 				parentElement = parentElement.getParent();
 
 			return parentElement != null ? parentElement.getCurSharedRef() : element;
 		}
 
 		public void maximize(CTabFolderEvent event) {
 		}
 
 		public void minimize(CTabFolderEvent event) {
 		}
 
 		public void restore(CTabFolderEvent event) {
 			setState(getElementToChange(event), null);
 		}
 	};
 
 	private MouseListener CTFDblClickListener = new MouseListener() {
 		public void mouseUp(MouseEvent e) {
 		}
 
 		public void mouseDown(MouseEvent e) {
 			// HACK! If this is an empty stack treat it as though it was the editor area
 			// and tear down any open trim stacks (see bug 384814)
 			CTabFolder ctf = (CTabFolder) e.widget;
 			MUIElement element = (MUIElement) ctf.getData(.);
 			if (element instanceof MPartStack && ctf.getItemCount() == 0) {
 				MWindow window = .getTopLevelWindowFor(element);
 				if (window != null) {
 					List<MToolControl> tcList = .findElements(windownull,
 							MToolControl.classnull);
 					for (MToolControl tc : tcList) {
 						if (tc.getObject() instanceof TrimStack) {
 							TrimStack ts = (TrimStacktc.getObject();
 							ts.showStack(false);
 						}
 					}
 				}
 			}
 		}
 
 		private MUIElement getElementToChange(MouseEvent event) {
 			CTabFolder ctf = (CTabFolder) event.widget;
 			MUIElement element = (MUIElement) ctf.getData(.);
 			if (element instanceof MArea) {
 				// set the state on the placeholder
 				return element.getCurSharedRef();
 			}
 
 			MUIElement parentElement = element.getParent();
 			while (parentElement != null && !(parentElement instanceof MArea))
 				parentElement = parentElement.getParent();
 
 			return parentElement != null ? parentElement.getCurSharedRef() : element;
 		}
 
 		public void mouseDoubleClick(MouseEvent e) {
 			// only maximize if the primary mouse button was used
 			if (e.button == 1) {
 				CTabFolder ctf = (CTabFolder) e.widget;
 				if (!ctf.getMaximizeVisible())
 					return;
 
 				// Only fire if we're in the 'tab' area
 				if (e.y > ctf.getTabHeight())
 					return;
 
 				MUIElement elementToChange = getElementToChange(e);
 				if (!elementToChange.getTags().contains()) {
 					setState(elementToChange);
 				} else {
 					setState(elementToChangenull);
 				}
 			}
 		}
 	};
 
 	private void setState(MUIElement elementString state) {
 		if (.equals(state)) {
 			element.getTags().remove();
 			element.getTags().add();
 		} else if (.equals(state)) {
 			element.getTags().remove();
 			element.getTags().add();
 		} else {
 			element.getTags().remove();
 			element.getTags().remove();
 		}
 
 	}
 
 	@Optional
 	private void subscribeTopicWidget(@UIEventTopic(UIEvents.UIElement.TOPIC_WIDGET) Event event) {
 		final MUIElement changedElement = (MUIElement) event.getProperty(EventTags.ELEMENT);
 		if (!(changedElement instanceof MPartStack) && !(changedElement instanceof MArea))
 			return;
 
 		final CTabFolder ctf = getCTFFor(changedElement);
 		if (ctf == null)
 			return;
 
 		MUIElement stateElement = changedElement;
 		if (changedElement instanceof MPartStack) {
 			MPartStack stack = (MPartStack) changedElement;
 			MArea area = getAreaFor(stack);
 			if (area != null && !(area.getWidget() instanceof CTabFolder))
 				stateElement = area.getCurSharedRef();
 		} else if (changedElement instanceof MArea)
 			stateElement = changedElement.getCurSharedRef();
 
 		adjustCTFButtons(stateElement);
 
 		ctf.removeCTabFolder2Listener(); // Prevent multiple instances
 		ctf.addCTabFolder2Listener();
 
 		ctf.removeMouseListener(); // Prevent multiple instances
 		ctf.addMouseListener();
 	}

Handles removals from the perspective

Parameters:
event
 
 
 	@Optional
 	private void subscribeTopicChildren(
 			@UIEventTopic(UIEvents.ElementContainer.TOPIC_CHILDREN) Event event) {
 		final MUIElement changedElement = (MUIElement) event.getProperty(EventTags.ELEMENT);
 		if (!(changedElement instanceof MPerspectiveStack)
 				|| .getTopLevelWindowFor(changedElement) == null)
 			return;
 
 		if (UIEvents.isREMOVE(event)) {
 			for (Object removedElement : UIEvents.asIterable(event, UIEvents.EventTags.OLD_VALUE)) {
 				MUIElement removed = (MUIElement) removedElement;
 				String perspectiveId = removed.getElementId();
 				MWindow window = .getTopLevelWindowFor(changedElement);
 				MTrimBar bar = .getTrim((MTrimmedWindow) window, SideValue.TOP);
 
 				// gather up any minimized stacks for this perspective...
 				List<MToolControl> toRemove = new ArrayList<MToolControl>();
 				for (MUIElement child : bar.getChildren()) {
 					String trimElementId = child.getElementId();
 					if (child instanceof MToolControl && trimElementId.contains(perspectiveId)) {
 						toRemove.add((MToolControl) child);
 					}
 				}
 
 				// ...and remove them
 				for (MToolControl minStack : toRemove) {
 					minStack.setToBeRendered(false);
 					bar.getChildren().remove(minStack);
 				}
 			}
 		}
 	}

Handles changes of the perspective

Parameters:
event
 
 
 	@Optional
 			@UIEventTopic(UIEvents.ElementContainer.TOPIC_SELECTEDELEMENT) Event event) {
 		final MUIElement changedElement = (MUIElement) event.getProperty(EventTags.ELEMENT);
 		if (!(changedElement instanceof MPerspectiveStack))
 			return;
 
 		MPerspectiveStack ps = (MPerspectiveStack) changedElement;
 		MWindow window = .getTopLevelWindowFor(ps);
 		List<MToolControl> tcList = .findElements(windownull, MToolControl.class,
 				null);
 
 		final MPerspective curPersp = ps.getSelectedElement();
 		if (curPersp != null) {
 			List<Stringtags = new ArrayList<String>();
 			tags.add(IPresentationEngine.MINIMIZED);
 
 			List<MUIElement> minimizedElements = .findElements(curPerspnull,
 					MUIElement.classtags);
 			// Show any minimized stack from the current perspective
 			String perspId = '(' + curPersp.getElementId() + ')';
 			for (MUIElement ele : minimizedElements) {
 				String fullId = ele.getElementId() + perspId;
 
 				for (MToolControl tc : tcList) {
 					if (fullId.equals(tc.getElementId())) {
 						tc.setToBeRendered(true);
 					}
 				}
 			}
 
 			// Find the editor 'area'
 			MPlaceholder eaPlaceholder = (MPlaceholder) .find(curPersp);
 			adjustCTFButtons(eaPlaceholder);
 		}
 
 		// Hide any minimized stacks from the old perspective
 		if (event.getProperty(EventTags.OLD_VALUE) instanceof MPerspective) {
 			MPerspective oldPersp = (MPerspective) event.getProperty(EventTags.OLD_VALUE);
 			String perspId = '(' + oldPersp.getElementId() + ')';
 			for (MToolControl tc : tcList) {
 				if (tc.getObject() instanceof TrimStack && tc.getElementId().contains(perspId)) {
 					TrimStack ts = (TrimStacktc.getObject();
 					ts.showStack(false);
 					tc.setToBeRendered(false);
 				}
 			}
 		}
 
 		final Shell winShell = (Shell) window.getWidget();
 		winShell.getDisplay().asyncExec(new Runnable() {
 			public void run() {
 				if (!winShell.isDisposed()) {
 					winShell.layout(truetrue);
 				}
 			}
 		});
 	}

Handles changes in tags

Parameters:
event
 
 
 	@Optional
 	private void subscribeTopicTagsChanged(
 			@UIEventTopic(UIEvents.ApplicationElement.TOPIC_TAGS) Event event) {
 			return;
 
 		Object changedObj = event.getProperty(EventTags.ELEMENT);
 
 		if (!(changedObj instanceof MUIElement))
 			return;
 
 		final MUIElement changedElement = (MUIElement) changedObj;
 
 		if (UIEvents.isADD(event)) {
 			if (UIEvents.contains(event, UIEvents.EventTags.NEW_VALUE, )) {
 				minimize(changedElement);
 			} else if (UIEvents.contains(event, UIEvents.EventTags.NEW_VALUE, )) {
 				maximize(changedElement);
 			}
 		} else if (UIEvents.isREMOVE(event)) {
 			if (UIEvents.contains(event, UIEvents.EventTags.OLD_VALUE, )) {
 				restore(changedElement);
 			} else if (UIEvents.contains(event, UIEvents.EventTags.OLD_VALUE, )) {
 				unzoom(changedElement);
 			}
 		}
 	}

Handles changes in the id of the element If a perspective ID changes fix any TrimStacks that reference the old id to point at the new id. This keeps trim stacks attached to the correct perspective when a perspective is saved with a new name.

Parameters:
event
 
 
 	@Optional
 	private void subscribeTopicElementId(
 			@UIEventTopic(UIEvents.ApplicationElement.TOPIC_ELEMENTID) Event event) {
 		Object changedObject = event.getProperty(EventTags.ELEMENT);
 
 		// Only care about MPerspective id changes
 		if (!(changedObject instanceof MPerspective))
 			return;
 
 		MPerspective perspective = (MPerspective) changedObject;
 
 		String newID = (Stringevent.getProperty(UIEvents.EventTags.NEW_VALUE);
 		String oldID = (Stringevent.getProperty(UIEvents.EventTags.OLD_VALUE);
 
 		// pattern is trimStackID(perspectiveID)
 		newID = '(' + newID + ')';
 		oldID = '(' + oldID + ')';
 
 		// Search the trim for the window containing the perspective
 		MWindow perspWin = .getTopLevelWindowFor(perspective);
 		if (perspWin == null)
 			return;
 
 		List<MToolControl> trimStacks = .findElements(perspWinnull,
 				MToolControl.classnull);
 		for (MToolControl trimStack : trimStacks) {
 			// Only care about MToolControls that are TrimStacks
 			if (..equals(trimStack.getContributionURI()))
 				trimStack.setElementId(trimStack.getElementId().replace(oldIDnewID));
 		}
 	}

Handles the event that the perspective is saved

Parameters:
event
 
 
 	@Optional
 	private void subscribeTopicPerspSaved(
 			@UIEventTopic(UIEvents.UILifeCycle.PERSPECTIVE_SAVED) Event event) {
 		final MPerspective savedPersp = (MPerspective) event.getProperty(EventTags.ELEMENT);
 		String cache = getTrimCache(savedPersp);
 		.getPersistedState().put(savedPersp.getElementId(), cache);
 	}
 
 	private String getTrimCache(MPerspective savedPersp) {
 		MWindow topWin = .getTopLevelWindowFor(savedPersp);
 		String perspIdStr = '(' + savedPersp.getElementId() + ')';
 
 		String cache = getWinCache(topWinperspIdStr);
 		for (MWindow dw : savedPersp.getWindows()) {
 			cache += getWinCache(dwperspIdStr);
 		}
 
 		return cache;
 	}
 
 	private String getWinCache(MWindow winString perspIdStr) {
 		String winStr = ""//$NON-NLS-1$
 
 		List<MPartStack> stackList = .findElements(winnull, MPartStack.classnull);
 		for (MPartStack stack : stackList) {
 			winStr += getStackTrimLoc(stackperspIdStr);
 		}
 		return winStr;
 	}
 
 	private String getStackTrimLoc(MPartStack stackString perspIdStr) {
 		MWindow stackWin = .getTopLevelWindowFor(stack);// getContainingWindow(stack);
 		MUIElement tcElement = .find(stack.getElementId() + perspIdStrstackWin);
 		if (tcElement == null)
 			return ""//$NON-NLS-1$
 
 		MTrimBar bar = (MTrimBar) ((MUIElement) tcElement.getParent());
 		int sideVal = bar.getSide().getValue();
 		int index = bar.getChildren().indexOf(tcElement);
 		return stack.getElementId() + ' ' + sideVal + ' ' + index + "#"//$NON-NLS-1$
 	}

Handles the event that the perspective is reset

Parameters:
event
 
 	@Optional
 	private void subscribeTopicPerspReset(
 			@UIEventTopic(UIEvents.UILifeCycle.PERSPECTIVE_RESET) Event event) {
 		final MPerspective resetPersp = (MPerspective) event.getProperty(EventTags.ELEMENT);
 
 		// Find any minimized stacks and show their trim
 		List<MUIElement> minimizedElements = .findElements(resetPerspnull,
 				MUIElement.class, Arrays.asList(IPresentationEngine.MINIMIZED));
 		for (MUIElement element : minimizedElements) {
 			createTrim(element);
 		}
 	}

Handles the event that the perspective is opened

Parameters:
event
 
 	@Optional
 	private void subscribeTopicPerspOpened(
 			@UIEventTopic(UIEvents.UILifeCycle.PERSPECTIVE_OPENED) Event event) {
 		final MPerspective openedPersp = (MPerspective) event.getProperty(EventTags.ELEMENT);
 
 		// Find any minimized stacks and show their trim
 		List<MUIElement> minimizedElements = .findElements(openedPerspnull,
 				MUIElement.class, Arrays.asList(IPresentationEngine.MINIMIZED));
 		for (MUIElement element : minimizedElements) {
 			createTrim(element);
 		}
 	}
 
 	private MArea getAreaFor(MPartStack stack) {
 		MUIElement parent = stack.getParent();
 		while (parent != null) {
 			if (parent instanceof MArea)
 				return (MArea) parent;
 			parent = parent.getParent();
 		}
 		return null;
 	}
 
 	private void setCTFButtons(CTabFolder ctf, MUIElement stateElementboolean hideButtons) {
 		if (hideButtons) {
 			ctf.setMinimizeVisible(false);
 			ctf.setMaximizeVisible(false);
 		} else {
 			if (stateElement.getTags().contains()) {
 				ctf.setMinimizeVisible(false);
 				ctf.setMaximizeVisible(true);
 				ctf.setMaximized(true);
 			} else if (stateElement.getTags().contains()) {
 				ctf.setMinimizeVisible(true);
 				ctf.setMaximizeVisible(true);
 				ctf.setMaximized(true);
 			} else {
 				ctf.setMinimizeVisible(true);
 				ctf.setMaximizeVisible(true);
 				ctf.setMinimized(false);
 				ctf.setMaximized(false);
 				ctf.layout();
 			}
 		}
 	}

Set the state of the min / max buttons on the CTF based on the model element's state. The input is expected to be the element that contains the min/max state info which should either be an MPartStack or an MPlaceholder for the shared area.

Parameters:
element The element to test
 
 	private void adjustCTFButtons(MUIElement element) {
 		if (!(element instanceof MPartStack) && !(element instanceof MPlaceholder))
 			return;
 
 		CTabFolder ctf = getCTFFor(element);
 		if (ctf == null)
 			return;
 
 		if (element instanceof MPlaceholder) {
 			setCTFButtons(ctfelementfalse);
 		} else {
 			MArea area = getAreaFor((MPartStack) element);
 			if (area == null) {
 				setCTFButtons(ctfelementfalse);
 			}
 		}
 	}
 
 	private CTabFolder getCTFFor(MUIElement element) {
 		if (element instanceof MArea) {
 			if (element.getWidget() instanceof CTabFolder)
 				return (CTabFolder) element.getWidget();
 			List<MPartStack> stacks = .findElements(elementnull, MPartStack.class,
 					null);
 			for (MPartStack stack : stacks) {
 				if (stack.getWidget() instanceof CTabFolder)
 					return (CTabFolder) stack.getWidget();
 			}
 		} else if (element.getWidget() instanceof CTabFolder)
 			return (CTabFolder) element.getWidget();
 		else if (element instanceof MPlaceholder) {
 			MPlaceholder ph = (MPlaceholder) element;
 			if (ph.getRef() instanceof MArea) {
 				return getCTFFor(ph.getRef());
 			}
 		}
 		return null;
 	}
 
 	boolean isEmptyPerspectiveStack(MUIElement element) {
 		if (!(element instanceof MPerspectiveStack))
 			return false;
 		MPerspectiveStack ps = (MPerspectiveStack) element;
 		return ps.getChildren().size() == 0;
 	}
 
 	void minimize(MUIElement element) {
 		// Can't minimize a non-rendered element
 		if (!element.isToBeRendered())
 			return;
 
 		if (isEmptyPerspectiveStack(element)) {
 			element.setVisible(false);
 			return;
 		}
 
 		createTrim(element);
 		element.setVisible(false);
 		adjustCTFButtons(element);
 		// Activate a part other than the trimStack so that if the tool item is pressed
 		// immediately it will still open the stack.
 		.requestActivation();
 	}
 
 	void restore(MUIElement element) {
 		MWindow window = .getTopLevelWindowFor(element);
 		String trimId = element.getElementId() + getMinimizedElementSuffix(element);
 		MToolControl trimStack = (MToolControl) .find(trimIdwindow);
 		if (trimStack == null || trimStack.getObject() == null) {
 			if (element instanceof MPerspectiveStack) {
 				element.setVisible(true);
 			}
 			return;
 		}
 
 		TrimStack ts = (TrimStacktrimStack.getObject();
 
 		adjustCTFButtons(element);
 
 		List<StringmaximizeTag = new ArrayList<String>();
 		maximizeTag.add(IPresentationEngine.MAXIMIZED);
 		List<MUIElement> curMax = .findElements(windownull, MUIElement.class,
 				maximizeTag, EModelService.PRESENTATION);
 		if (curMax.size() > 0) {
 			MUIElement maxElement = curMax.get(0);
 			List<MUIElement> elementsLeftToRestore = getElementsToRestore(maxElement);
 
 			// Are any stacks still minimized ?
 			boolean unMax = true;
 			for (MUIElement toRestore : elementsLeftToRestore) {
 				if (!toRestore.isVisible())
 					unMax = false;
 			}
 			if (unMax) {
 				maxElement.getTags().remove(IPresentationEngine.MAXIMIZED);
 			}
 		}
 	}
 
 	void maximize(final MUIElement element) {
 		if (!element.isToBeRendered())
 			return;
 
 		List<MUIElement> elementsToMinimize = getElementsToMinimize(element);
 		Shell hostShell = (Shell) .getTopLevelWindowFor(element).getWidget();
 		MWindow win = getWindowFor(element);
 
 		FaderAnimationFeedback fader = new FaderAnimationFeedback(hostShell);
 		AnimationEngine engine = new AnimationEngine(win.getContext(), fader, 300);
 		engine.schedule();
 
 		// Restore any currently maximized element
 		restoreMaximizedElement(elementwin);
 
 		for (MUIElement toMinimize : elementsToMinimize) {
 			toMinimize.getTags().add();
 			toMinimize.getTags().add();
 		}
 
 		adjustCTFButtons(element);
 	}

Parameters:
element
Returns:
The list of elements that need to be minimized during a maximize
 
 	private List<MUIElement> getElementsToMinimize(MUIElement element) {
 		MWindow win = getWindowFor(element);
 		MPerspective persp = .getActivePerspective(win);
 
 		List<MUIElement> elementsToMinimize = new ArrayList<MUIElement>();
 		int loc = .getElementLocation(element);
 		if ((loc & EModelService.OUTSIDE_PERSPECTIVE) != 0) {
 			// Minimize all other global stacks
 			List<MPartStack> globalStacks = .findElements(winnull, MPartStack.class,
 					null, EModelService.OUTSIDE_PERSPECTIVE);
 			for (MPartStack gStack : globalStacks) {
 				if (gStack == element || !gStack.isToBeRendered())
 					continue;
 
 				if (gStack.getWidget() != null && !gStack.getTags().contains()) {
 					elementsToMinimize.add(gStack);
 				}
 			}
 
 			// Minimize the Perspective Stack
 			MUIElement perspStack = null;
 			if (persp == null) {
 				// special case for windows with no perspectives (eg bug 372614:
 				// intro part with no perspectives). We know we're outside
 				// of the perspective stack, so find it top-down
 				List<MPerspectiveStack> pStacks = .findElements(winnull,
 						MPerspectiveStack.classnull);
 				perspStack = (pStacks.size() > 0) ? pStacks.get(0) : null;
 			} else {
 				perspStack = persp.getParent();
 			}
 			if (perspStack != null) {
 				if (perspStack.getElementId() == null || perspStack.getElementId().length() == 0)
 					perspStack.setElementId("PerspectiveStack"); //$NON-NLS-1$
 
 				elementsToMinimize.add(perspStack);
 			}
 		} else {
 			List<MPartStack> stacks = .findElements(persp == null ? win : perspnull,
 					MPartStack.classnull, EModelService.PRESENTATION);
 			for (MPartStack theStack : stacks) {
 				if (theStack == element || !theStack.isToBeRendered())
 					continue;
 
 				// Exclude stacks in DW's
 				if (getWindowFor(theStack) != win)
 					continue;
 
 				loc = .getElementLocation(theStack);
 				if (loc != EModelService.IN_SHARED_AREA && theStack.getWidget() != null
 						&& theStack.isVisible() && !theStack.getTags().contains()) {
 					elementsToMinimize.add(theStack);
 				}
 			}
 
 			// Find any 'standalone' views *not* in a stack
 			List<StringstandaloneTag = new ArrayList<String>();
 			standaloneTag.add(IPresentationEngine.STANDALONE);
 			List<MPlaceholder> standaloneViews = .findElements(persp == null ? win
 					: perspnull, MPlaceholder.classstandaloneTag, EModelService.PRESENTATION);
 			for (MPlaceholder part : standaloneViews) {
 				if (!part.isToBeRendered())
 					continue;
 				elementsToMinimize.add(part);
 			}
 
 			// Find the editor 'area'
 			if (persp != null) {
 				MPlaceholder eaPlaceholder = (MPlaceholder) 
 						.find(persp);
 				if (element != eaPlaceholder && eaPlaceholder != null
 						&& eaPlaceholder.getWidget() != null && eaPlaceholder.isVisible()) {
 					elementsToMinimize.add(eaPlaceholder);
 				}
 			}
 		}
 
 		return elementsToMinimize;
 	}

Restore any currently maximized element (except the one we're in the process of maximizing

Parameters:
element
win
 
 	private void restoreMaximizedElement(final MUIElement element, MWindow win) {
 		MPerspective elePersp = .getPerspectiveFor(element);
 		List<StringmaxTag = new ArrayList<String>();
 		maxTag.add();
 		List<MUIElement> curMax = .findElements(winnull, MUIElement.classmaxTag);
 		if (curMax.size() > 0) {
 			for (MUIElement maxElement : curMax) {
 				// Only unmax elements in this window
 				if (getWindowFor(maxElement) != win)
 					continue;
 
 				MPerspective maxPersp = .getPerspectiveFor(maxElement);
 				if (maxPersp != elePersp)
 					continue;
 				if (maxElement == element)
 					continue;
 				 = true;
 				try {
 					maxElement.getTags().remove();
 				} finally {
 					 = false;
 				}
 			}
 		}
 	}

Return the MWindow containing this element (if any). This may either be a 'top level' window -or- a detached window. This allows the min.max code to only affect elements in the window containing the element.

Parameters:
element The element to check
Returns:
the window containing the element.
 
 	private MWindow getWindowFor(MUIElement element) {
 		MUIElement parent = element.getParent();
 
 		// We rely here on the fact that a DW's 'getParent' will return
 		// null since it's not in the 'children' hierarchy
 		while (parent != null && !(parent instanceof MWindow))
 			parent = parent.getParent();
 
 		// A detached window will end up with getParent() == null
 		return (MWindow) parent;
 	}
 
 	void unzoom(final MUIElement element) {
 		MWindow win = getWindowFor(element);
 
 		Shell hostShell = (Shell) win.getWidget();
 		FaderAnimationFeedback fader = new FaderAnimationFeedback(hostShell);
 		AnimationEngine engine = new AnimationEngine(win.getContext(), fader, 300);
 		engine.schedule();
 
 		List<MUIElement> elementsToRestore = getElementsToRestore(element);
 		for (MUIElement toRestore : elementsToRestore) {
 			toRestore.getTags().remove(IPresentationEngine.MINIMIZED_BY_ZOOM);
 			toRestore.getTags().remove(IPresentationEngine.MINIMIZED);
 		}
 
 		adjustCTFButtons(element);
 
 		// There are more views available to be active...
 		.requestActivation();
 	}

Parameters:
element
Returns:
The list of elements that need to be restored by an unzoom
 
 	private List<MUIElement> getElementsToRestore(MUIElement element) {
 		MWindow win = getWindowFor(element);
 		MPerspective persp = .getActivePerspective(win);
 
 		List<MUIElement> elementsToRestore = new ArrayList<MUIElement>();
 
 		List<StringminTag = new ArrayList<String>();
 		minTag.add(IPresentationEngine.MINIMIZED_BY_ZOOM);
 
 		// Restore any minimized stacks
 		boolean outsidePerspectives = (.getElementLocation(element) & EModelService.OUTSIDE_PERSPECTIVE) != 0;
 		List<MPartStack> stacks = .findElements(winnull, MPartStack.classminTag,
 				EModelService.PRESENTATION);
 		for (MPartStack theStack : stacks) {
 			if (theStack.getWidget() != null) {
 				// Make sure we don't restore perspective-based stacks if we're
 				// unzoooming an element outside the perspectives
 				if (outsidePerspectives) {
 					int stackLoc = .getElementLocation(theStack);
 					if ((stackLoc & EModelService.OUTSIDE_PERSPECTIVE) == 0)
 						continue;
 				}
 
 				// Make sure we're only working on *our* window
 				if (getWindowFor(theStack) == win) {
 					elementsToRestore.add(theStack);
 				}
 			}
 		}
 
 		// Restore any minimized standalone views
 		List<MPlaceholder> views = .findElements(winnull, MPlaceholder.classminTag,
 				EModelService.PRESENTATION);
 		for (MPlaceholder ph : views) {
 			if (ph.getWidget() != null && getWindowFor(ph) == win) {
 				elementsToRestore.add(ph);
 			}
 		}
 
 		// Find the editor 'area'
 		MPlaceholder eaPlaceholder = (MPlaceholder) .find(,
 				persp == null ? win : persp);
 		if (element != eaPlaceholder && eaPlaceholder != null
 				&& eaPlaceholder.getTags().contains()) {
 			elementsToRestore.add(eaPlaceholder);
 		}
 
 		// Find the Perspective Stack
 		int loc = .getElementLocation(element);
 		if ((loc & EModelService.OUTSIDE_PERSPECTIVE) != 0) {
 			List<MPerspectiveStack> psList = .findElements(winnull,
 					MPerspectiveStack.classnull);
 			if (psList.size() == 1) {
 				MPerspectiveStack perspStack = psList.get(0);
 				if (element != perspStack && perspStack != null
 						&& perspStack.getTags().contains()) {
 					elementsToRestore.add(perspStack);
 				}
 			}
 		}
 
 		return elementsToRestore;
 	}
 
 	private void createTrim(MUIElement element) {
 		MTrimmedWindow window = (MTrimmedWindow) getWindowFor(element);
 		Shell winShell = (Shell) window.getWidget();
 
 		// Is there already a TrimControl there ?
 		String trimId = element.getElementId() + getMinimizedElementSuffix(element);
 		MToolControl trimStack = (MToolControl) .find(trimIdwindow);
 
 		if (trimStack == null) {
 			trimStack = MenuFactoryImpl.eINSTANCE.createToolControl();
 			trimStack.setElementId(trimId);
 			trimStack.setContributionURI(.);
 			trimStack.getTags().add("TrimStack"); //$NON-NLS-1$
 
 			// Check if we have a cached location
 			MTrimBar bar = getBarForElement(elementwindow);
 			int index = getCachedIndex(element);
 			if (index == -1 || index >= bar.getChildren().size())
 				bar.getChildren().add(trimStack);
 			else
 				bar.getChildren().add(indextrimStack);
 
 			bar.setVisible(true);
 
 			// get the parent trim bar, see bug 320756
 			if (bar.getWidget() == null) {
 				// ask it to be rendered
 				bar.setToBeRendered(true);
 
 				// create the widget
 				.get(IPresentationEngine.class)
 						.createGui(barwinShellwindow.getContext());
 			}
 		} else {
 			// get the parent trim bar, see bug 320756
 			MUIElement parent = trimStack.getParent();
 			parent.setVisible(true);
 			if (parent.getWidget() == null) {
 				// ask it to be rendered
 				parent.setToBeRendered(true);
 				// create the widget
 				.get(IPresentationEngine.class).createGui(parentwinShell,
 						window.getContext());
 			}
 			trimStack.setToBeRendered(true);
 		}
 	}
 
 	private String getCachedInfo(MUIElement element) {
 		String cacheId = ;
 		MPerspective persp = .getPerspectiveFor(element);
 		if (persp != null)
 			cacheId = persp.getElementId();
 		String cacheInfo = .getPersistedState().get(cacheId);
 
 		return cacheInfo;
 	}
 
 	private int getCachedIndex(MUIElement element) {
 		String cache = getCachedInfo(element);
 		if (cache == null)
 			return -1;
 
 		String[] stacks = cache.split("#"); //$NON-NLS-1$
 		for (String stackInfo : stacks) {
 			String[] vals = stackInfo.split(" "); //$NON-NLS-1$
 			if (vals[0].equals(element.getElementId())) {
 				return Integer.parseInt(vals[2]);
 			}
 		}
 		return -1;
 	}
 
 	private SideValue getCachedBar(MUIElement element) {
 		String cache = getCachedInfo(element);
 		if (cache == null)
 			return null;
 
 		String[] stacks = cache.split("#"); //$NON-NLS-1$
 		for (String stackInfo : stacks) {
 			String[] vals = stackInfo.split(" "); //$NON-NLS-1$
 			if (vals[0].equals(element.getElementId())) {
 				int sideVal = Integer.parseInt(vals[1]);
 				return SideValue.get(sideVal);
 			}
 		}
 		return null;
 	}
 
 	private MTrimBar getBarForElement(MUIElement element, MTrimmedWindow window) {
 		SideValue side = getCachedBar(element);
 		if (side == null) {
 			Shell winShell = (Shell) window.getWidget();
 			Rectangle winBounds = winShell.getBounds();
 			int winCenterX = winBounds.width / 2;
 			Control stackCtrl = (Control) element.getWidget();
 			Rectangle stackBounds = stackCtrl.getBounds();
 			stackBounds = winShell.getDisplay().map(stackCtrlwinShellstackBounds);
 			int stackCenterX = stackBounds.x + (stackBounds.width / 2);
 			side = stackCenterX < winCenterX ? SideValue.LEFT : SideValue.RIGHT;
 		}
 		MTrimBar bar = .getTrim(windowside);
 
 		return bar;
 	}
 
 	private String getMinimizedElementSuffix(MUIElement element) {
 		String id = ;
 		MPerspective persp = .getPerspectiveFor(element);
 		if (persp != null) {
			id = '(' + persp.getElementId() + ')';
		return id;
New to GrepCode? Check out our FAQ X