org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/MinMaxAddon.java

/*******************************************************************************
 * Copyright (c) 2011, 2012 Kai Toedter, Rushan R. Gilmullin and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0 
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 * 
 * Contributors:
 * 	   Kai Toedter - initial API and implementation
 *     Rushan R. Gilmullin -  completion
 *******************************************************************************/

package org.eclipse.osbp.vaaclipse.behaviour;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;

import org.eclipse.e4.core.commands.EHandlerService;
import org.eclipse.e4.core.contexts.IEclipseContext;
import org.eclipse.e4.core.services.events.IEventBroker;
import org.eclipse.e4.ui.model.application.MApplication;
import org.eclipse.e4.ui.model.application.ui.MElementContainer;
import org.eclipse.e4.ui.model.application.ui.MUIElement;
import org.eclipse.e4.ui.model.application.ui.MUILabel;
import org.eclipse.e4.ui.model.application.ui.SideValue;
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.MPart;
import org.eclipse.e4.ui.model.application.ui.basic.MPartSashContainer;
import org.eclipse.e4.ui.model.application.ui.basic.MPartSashContainerElement;
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.MTrimElement;
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.MDirectToolItem;
import org.eclipse.e4.ui.model.application.ui.menu.MToolBar;
import org.eclipse.e4.ui.model.application.ui.menu.MToolItem;
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.osgi.service.event.Event;
import org.osgi.service.event.EventHandler;
import org.eclipse.osbp.commons.geom.Bounds;
import org.eclipse.osbp.vaaclipse.api.Events;
import org.eclipse.osbp.vaaclipse.api.WidgetInfo;
import org.eclipse.osbp.vaaclipse.presentation.engine.PresentationEngine;
import org.eclipse.osbp.vaaclipse.presentation.renderers.GenericRenderer;

@SuppressWarnings("restriction")
public class MinMaxAddon {
	public static final String ADDONS_MINMAX_TRIM_STACK_ID = "org.eclipse.osbp.vaaclipse.behaviour.trimStackId";

	static final String ID_SUFFIX = "(minimized)"; //$NON-NLS-1$

	// tags representing the min/max state
	public static final String MINIMIZED = IPresentationEngine.MINIMIZED;
	public static final String MAXIMIZED = IPresentationEngine.MAXIMIZED;
	public static final String MINIMIZED_BY_ZOOM = IPresentationEngine.MINIMIZED_BY_ZOOM;

	private final IEventBroker eventBroker;
	private final EModelService modelService;
	protected boolean ignoreTagChanges;

	@Inject
	private IEclipseContext context;

	@Inject
	EPartService partService;

	@Inject
	private EHandlerService handlerService;

	@Inject
	private WidgetInfo widgetInfo;

	private Map<MToolBar, MPerspective> barPerspectiveInfo = new HashMap<MToolBar, MPerspective>();
	private Set<MUIElement> minimizedElements = new HashSet<MUIElement>();

	// TODO: dispose elements of this map
	public Map<MToolItem, MPart> item2Element = new HashMap<MToolItem, MPart>();
	public Map<MPart, MUIElement> part2element = new HashMap<MPart, MUIElement>();

	@Inject
	public MinMaxAddon(IEventBroker eventBroker, EModelService modelService,
			MApplication application) {
		this.eventBroker = eventBroker;
		this.modelService = modelService;
	}

	private EventHandler widgetHandler = new EventHandler() {
		public void handleEvent(org.osgi.service.event.Event event) {
			Object changedObj = event.getProperty(UIEvents.EventTags.ELEMENT);
			if (!minimizedElements.contains(changedObj))
				return;
			MUIElement minimizedElement = (MUIElement) changedObj;
			if (minimizedElement.getWidget() != null) {
				MToolBar toolBar = getToolBarForMinimizedElement(minimizedElement);
				updateToolBar(minimizedElement, toolBar);
			}
		}
	};

	private EventHandler toBeRenderedHandler = new EventHandler() {
		public void handleEvent(org.osgi.service.event.Event event) {
			MUIElement changedElement = (MUIElement) event
					.getProperty(UIEvents.EventTags.ELEMENT);

			// if one of the kids changes state, re-scrape the CTF
			MUIElement parentElement = changedElement.getParent();
			if (minimizedElements.contains(parentElement)) {
				updateToolBar(parentElement,
						getToolBarForMinimizedElement(parentElement));
			}
		}
	};

	private EventHandler childrenHandler = new EventHandler() {
		public void handleEvent(org.osgi.service.event.Event event) {
			Object changedObj = event.getProperty(UIEvents.EventTags.ELEMENT);

			// if a child has been added or removed, re-scape the CTF
			if (minimizedElements.contains(changedObj)) {
				updateToolBar((MUIElement) changedObj,
						getToolBarForMinimizedElement((MUIElement) changedObj));
			}
		}
	};

	@PostConstruct
	void postConstruct() {
		eventBroker.subscribe(UIEvents.ApplicationElement.TOPIC_TAGS,
				tagListener);
		eventBroker.subscribe(UIEvents.ElementContainer.TOPIC_SELECTEDELEMENT,
				selectPerspectiveHandler);
		eventBroker.subscribe(UIEvents.UIElement.TOPIC_VISIBLE,
				visibilityHandler);
		eventBroker.subscribe(UIEvents.UIElement.TOPIC_WIDGET, widgetHandler);
		eventBroker.subscribe(UIEvents.ElementContainer.TOPIC_CHILDREN,
				childrenHandler);
		eventBroker.subscribe(UIEvents.UIElement.TOPIC_TOBERENDERED,
				toBeRenderedHandler);

		// context.set(Behaviour.class, this);
	}

	@PreDestroy
	void preDestroy() {
		eventBroker.unsubscribe(tagListener);
		eventBroker.unsubscribe(selectPerspectiveHandler);
		eventBroker.unsubscribe(visibilityHandler);
		eventBroker.unsubscribe(widgetHandler);
		eventBroker.unsubscribe(childrenHandler);
		eventBroker.unsubscribe(toBeRenderedHandler);
	}

	private final EventHandler tagListener = new EventHandler() {
		@Override
		public void handleEvent(Event event) {
			if (ignoreTagChanges) {
				return;
			}

			Object changedObj = event.getProperty(EventTags.ELEMENT);
			String eventType = (String) event
					.getProperty(UIEvents.EventTags.TYPE);
			String tag = (String) event
					.getProperty(UIEvents.EventTags.NEW_VALUE);
			String oldVal = (String) event
					.getProperty(UIEvents.EventTags.OLD_VALUE);

			if (!(changedObj instanceof MUIElement)) {
				return;
			}

			final MUIElement changedElement = (MUIElement) changedObj;

			if (UIEvents.EventTypes.ADD.equals(eventType)) {
				if (MINIMIZED.equals(tag)) {
					minimize(changedElement);
				} else if (MAXIMIZED.equals(tag)) {
					maximize(changedElement);
				}
			} else if (UIEvents.EventTypes.REMOVE.equals(eventType)) {
				if (MINIMIZED.equals(oldVal)) {
					restore(changedElement);
				} else if (MAXIMIZED.equals(oldVal)) {
					unzoom(changedElement);
				}
			}
		}
	};

	private EventHandler selectPerspectiveHandler = new EventHandler() {
		public void handleEvent(Event event) {
			Object element = event.getProperty(UIEvents.EventTags.ELEMENT);

			if (!(element instanceof MPerspectiveStack))
				return;

			MPerspectiveStack stack = (MPerspectiveStack) element;

			// Gather up the elements that are being 'hidden' by this change
			MUIElement oldSel = (MUIElement) event
					.getProperty(UIEvents.EventTags.OLD_VALUE);

			if (oldSel != null) {
				for (Map.Entry<MToolBar, MPerspective> entry : barPerspectiveInfo
						.entrySet()) {
					if (oldSel == entry.getValue()) {
						MToolBar toolBar = entry.getKey();
						if (toolBar.isVisible()) {
							toolBar.setVisible(false);
						}
					}
				}
			}

			if (stack.getSelectedElement() != null) {
				for (Map.Entry<MToolBar, MPerspective> entry : barPerspectiveInfo
						.entrySet()) {
					if (stack.getSelectedElement() == entry.getValue()) {
						MToolBar toolBar = entry.getKey();
						if (!toolBar.isVisible()) {
							toolBar.setVisible(true);
							MTrimBar parentTrimBar = (MTrimBar) (MElementContainer<?>) toolBar
									.getParent();
							if (!parentTrimBar.isVisible())
								parentTrimBar.setVisible(true);
						}
					}
				}
			}
		}
	};

	private final EventHandler visibilityHandler = new EventHandler() {
		@Override
		public void handleEvent(Event event) {
			MUIElement changedElement = (MUIElement) event
					.getProperty(UIEvents.EventTags.ELEMENT);

			if (changedElement instanceof MTrimElement) {
				MTrimBar parentTrimBar = (MTrimBar) (MElementContainer<?>) changedElement
						.getParent();
				if (!parentTrimBar.isVisible())
					return;

				boolean hasVisibleChilds = false;
				for (MTrimElement trimElelement : parentTrimBar.getChildren()) {
					if (trimElelement.isVisible()) {
						hasVisibleChilds = true;
						break;
					}
				}

				if (!hasVisibleChilds)
					parentTrimBar.setVisible(false);
			}
		}
	};

	protected void minimize(MUIElement element) {
		if (!element.isToBeRendered()) {
			return;
		}
		MToolBar toolBar = createTrim(element);
		element.setVisible(false);
		minimizedElements.add(element);
		// Activate a part other than the trimStack so that if the tool item is
		// pressed
		// immediately it will still open the stack.
		partService.requestActivation();

		// send the minimize event
		Map<String, Object> parameters = new HashMap<String, Object>();
		parameters.put(Events.MinMaxEvents.PARAMETER_ELEMENT, element);
		parameters.put(Events.MinMaxEvents.PARAMETER_TOOLBAR, toolBar);
		parameters.put(Events.MinMaxEvents.PARAMETER_TRIMBAR,
				toolBar.getParent());
		eventBroker
				.send(Events.MinMaxEvents.EVENT_MINIMIZE_ELEMENT, parameters);
	}

	protected void unzoom(MUIElement element) {
		MWindow win = modelService.getTopLevelWindowFor(element);

		List<MPartStack> stacks = modelService.findElements(win, null,
				MPartStack.class, null, EModelService.PRESENTATION);
		for (MPartStack theStack : stacks) {
			if (theStack.getWidget() != null
					&& theStack.getTags().contains(MINIMIZED)
					&& theStack.getTags().contains(MINIMIZED_BY_ZOOM)) {
				theStack.getTags().remove(MINIMIZED);
			}
		}

		List<MPlaceholder> placeholders = modelService.findElements(win, null,
				MPlaceholder.class, null, EModelService.PRESENTATION);
		for (MPlaceholder ph : placeholders) {
			if (ph.getWidget() != null && ph.getTags().contains(MINIMIZED)
					&& ph.getTags().contains(MINIMIZED_BY_ZOOM)) {
				ph.getTags().remove(MINIMIZED);
			}
		}
	}

	public void resetWindows(MUIElement element) {
		ignoreTagChanges = true;
		MWindow window = modelService.getTopLevelWindowFor(element);

		List<MPartStack> stacks = modelService.findElements(window, null,
				MPartStack.class, null, EModelService.PRESENTATION);
		for (MPartStack partStack : stacks) {
			if (partStack.getWidget() != null) {
				if (partStack.getTags().contains(MINIMIZED)) {
					partStack.getTags().remove(MINIMIZED);
				}
				if (partStack.getTags().contains(MAXIMIZED)) {
					partStack.getTags().remove(MAXIMIZED);
				}
				if (partStack.getTags().contains(MINIMIZED_BY_ZOOM)) {
					partStack.getTags().remove(MINIMIZED_BY_ZOOM);
				}
			}
			partStack.setVisible(true);
		}
		ignoreTagChanges = false;

		if (window instanceof MTrimmedWindow) {
			MTrimmedWindow trimmedWindow = (MTrimmedWindow) window;
			List<MTrimBar> trimBars = trimmedWindow.getTrimBars();
			for (MTrimBar trimBar : trimBars) {
				if (trimBar.getSide() == SideValue.LEFT
						|| trimBar.getSide() == SideValue.RIGHT) {
					trimBar.getChildren().clear();
					trimBar.setVisible(false);
				}
			}
		}
	}

	protected void restore(MUIElement element) {

		// if the element is minimized, then the widget of this element maybe
		// (but not fact) detached from its real parent
		// and attached to popup window and the widget's visible property is
		// true. We must undo this changes
		// before start the restore operation
		Object currentParent = widgetInfo.getParent(element.getWidget());
		Object realParent = element.getParent().getWidget();
		if (currentParent != realParent) // if the current parent is not equal
											// (or null) the real parent,
		{// then reattach the widget to real parent
			((GenericRenderer) element.getParent().getRenderer())
					.processContents(element.getParent());
		}

		element.getTags().remove(MINIMIZED_BY_ZOOM);
		element.getTags().remove(MINIMIZED);
		element.setVisible(true);
		minimizedElements.remove(element);

		MTrimBar trimBar = getTrimBarForMinimizedElement(element);
		MToolBar toolBar = getToolBarForMinimizedElement(element);

		if (trimBar != null || toolBar != null) {

			barPerspectiveInfo.remove(toolBar);

			toolBar.setToBeRendered(false);
			trimBar.getChildren().remove(toolBar);
			if (trimBar.getChildren().size() == 0) {
				trimBar.setVisible(false);
			}
		}

		Map<String, Object> parameters = new HashMap<String, Object>();
		parameters.put(Events.MinMaxEvents.PARAMETER_ELEMENT, element);
		eventBroker.send(Events.MinMaxEvents.EVENT_RESTORE_ELEMENT, parameters);
	}

	protected void maximize(MUIElement element) {
		if (!element.isToBeRendered()) {
			return;
		}

		MWindow mWindow = getWindowFor(element);
		MPerspective persp = modelService.getActivePerspective(mWindow);

		List<String> maxTag = new ArrayList<String>();
		maxTag.add(MAXIMIZED);
		List<MUIElement> curMax = modelService
				.findElements(persp == null ? mWindow : persp, null,
						MUIElement.class, maxTag);
		if (curMax.size() > 0) {
			for (MUIElement maxElement : curMax) {
				if (maxElement == element) {
					continue;
				}
				ignoreTagChanges = true;
				try {
					maxElement.getTags().remove(MAXIMIZED);
				} finally {
					ignoreTagChanges = false;
				}
			}
		}

		// Stacks
		List<MPartStack> stacks = modelService.findElements(
				persp == null ? mWindow : persp, null, MPartStack.class, null,
				EModelService.PRESENTATION);
		for (MPartStack theStack : stacks) {
			if (theStack == element || !theStack.isToBeRendered()) {
				continue;
			}

			// Exclude stacks in DW's
			// if (getWindowFor(theStack) != mWindow) {
			// continue;
			// }

			int location = modelService.getElementLocation(theStack);
			if (location != EModelService.IN_SHARED_AREA
					&& theStack.getWidget() != null
					&& !theStack.getTags().contains(MINIMIZED)) {
				theStack.getTags().add(MINIMIZED_BY_ZOOM);
				theStack.getTags().add(MINIMIZED);
			}
		}

		// Placeholders
		List<MPlaceholder> placeholders = modelService.findElements(
				persp == null ? mWindow : persp, null, MPlaceholder.class,
				null, EModelService.PRESENTATION);
		for (MPlaceholder thePlaceholder : placeholders) {
			if (thePlaceholder == element
					|| !thePlaceholder.isToBeRendered()
					|| !(thePlaceholder.getRef() instanceof MElementContainer<?>)) {
				continue;
			}

			// Exclude stacks in DW's
			// if (getWindowFor(thePlaceholder) != mWindow) {
			// continue;
			// }

			int location = modelService.getElementLocation(thePlaceholder);
			if (location != EModelService.IN_SHARED_AREA
					&& thePlaceholder.getWidget() != null
					&& !thePlaceholder.getTags().contains(MINIMIZED)) {
				thePlaceholder.getTags().add(MINIMIZED_BY_ZOOM);
				thePlaceholder.getTags().add(MINIMIZED);
			}
		}
	}

	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;
	}

	private MToolBar createTrim(MUIElement element) {
		MTrimmedWindow window = (MTrimmedWindow) getWindowFor(element);
		MPerspective activePerspective = modelService
				.getActivePerspective(window);

		if (element.getElementId() == null)
			element.setElementId(UUID.randomUUID().toString());

		// Is there already a TrimControl there ?
		String trimId = element.getElementId()
				+ getMinimizedElementSuffix(element);
		MToolBar toolBar = (MToolBar) modelService.find(trimId, window);

		if (toolBar == null) {
			toolBar = MenuFactoryImpl.eINSTANCE.createToolBar();
			toolBar.setElementId(trimId);

			// Check if we have a cached location
			MTrimBar bar = getBarForElement(element, window);
			bar.getChildren().add(toolBar);
			bar.setVisible(true);

			// get the parent trim bar, see bug 320756
			PresentationEngine presentationEngine = (PresentationEngine) context
					.get(IPresentationEngine.class);

			updateToolBar(element, toolBar);

			if (bar.getWidget() == null) {
				// ask it to be rendered
				bar.setToBeRendered(true);

				// create the widget
				presentationEngine.createGui(bar);
			} else {
				toolBar.setToBeRendered(true);
				presentationEngine.createGui(toolBar);
			}
		} else {
			// get the parent trim bar, see bug 320756
			MUIElement parent = toolBar.getParent();
			parent.setVisible(true);
			if (parent.getWidget() == null) {
				// ask it to be rendered
				parent.setToBeRendered(true);
				// create the widget
				PresentationEngine presentationEngine = (PresentationEngine) context
						.get(IPresentationEngine.class);
				presentationEngine.createGui(parent);
			}

			updateToolBar(element, toolBar);

			toolBar.setToBeRendered(true);
		}

		barPerspectiveInfo.put(toolBar, activePerspective);
		return toolBar;
	}

	private void updateToolBar(MUIElement element, MToolBar toolBar) {
		toolBar.getChildren().clear();

		MDirectToolItem toolItem = MenuFactoryImpl.eINSTANCE
				.createDirectToolItem();
		toolItem.setIconURI("platform:/plugin/org.eclipse.osbp.vaaclipse.resources/VAADIN/themes/vaaclipse_default_theme/img/restore1.png");
		toolItem.setContributionURI("bundleclass://org.eclipse.osbp.vaaclipse.behaviour/org.eclipse.osbp.vaaclipse.behaviour.RestoreHandler");
		// toolItem.getTransientData().put("minimizedStack", element);
		toolItem.setContainerData(element.getElementId());
		toolBar.getChildren().add(toolItem);

		if (element instanceof MPlaceholder) {
			MDirectToolItem partItem = MenuFactoryImpl.eINSTANCE
					.createDirectToolItem();
			partItem.setElementId(UUID.randomUUID().toString());
			partItem.setContributionURI("bundleclass://org.eclipse.osbp.vaaclipse.behaviour/org.eclipse.osbp.vaaclipse.behaviour.FastViewHandler");

			MUILabel labelElement = getLabelElement(element);
			if (labelElement != null) {
				if (labelElement.getIconURI() != null
						&& labelElement.getIconURI().trim().length() > 0)
					partItem.setIconURI(labelElement.getIconURI());
				else
					partItem.setIconURI("platform:/plugin/org.eclipse.osbp.vaaclipse.resources/VAADIN/themes/vaaclipse_default_theme/img/editor_area.png");
				toolBar.getChildren().add(partItem);
				MPart part = getLeafPart(element);
				item2Element.put(partItem, part);
				part2element.put(part, element);
			}
		} else {
			@SuppressWarnings("unchecked")
			MElementContainer<MUIElement> partStack = (MElementContainer<MUIElement>) element;
			for (MUIElement stackElement : partStack.getChildren()) {
				if (!stackElement.isToBeRendered()) {
					continue;
				}

				MUIElement el = stackElement instanceof MPlaceholder ? ((MPlaceholder) stackElement)
						.getRef() : stackElement;
				if (el instanceof MPart) {
					MDirectToolItem partItem = MenuFactoryImpl.eINSTANCE
							.createDirectToolItem();
					partItem.setContributionURI("bundleclass://org.eclipse.osbp.vaaclipse.behaviour/org.eclipse.osbp.vaaclipse.behaviour.FastViewHandler");

					MUILabel labelElement = getLabelElement(stackElement);
					String iconURI = labelElement.getIconURI();
					if (iconURI == null || iconURI.trim().isEmpty())
						iconURI = "platform:/plugin/org.eclipse.osbp.vaaclipse.resources/VAADIN/themes/vaaclipse_default_theme/img/blank_part_label.png";
					partItem.setIconURI(iconURI);
					toolBar.getChildren().add(partItem);

					item2Element.put(partItem, (MPart) el);
					part2element.put((MPart) el, element);
				}
			}
		}
	}

	private MPart getLeafPart(MUIElement element) {
		if (element instanceof MPlaceholder)
			return getLeafPart(((MPlaceholder) element).getRef());

		if (element instanceof MElementContainer<?>)
			return getLeafPart(((MElementContainer<?>) element)
					.getSelectedElement());

		if (element instanceof MPart)
			return (MPart) element;

		return null;
	}

	private MUILabel getLabelElement(MUIElement element) {
		if (element instanceof MPlaceholder) {
			element = ((MPlaceholder) element).getRef();
		}

		return (MUILabel) (element instanceof MUILabel ? element : null);
	}

	private MTrimBar getBarForElement(MUIElement element, MTrimmedWindow window) {
		SideValue side = SideValue.LEFT;

		// SideValue side = getCachedBar(element);
		// if (side == null) {

		Bounds winBounds = new Bounds(0, 0, 1000, 1000);
		double winCenterX = winBounds.w / 2;
		Bounds stackBounds = calculateBounds(element, window, winBounds);
		if (stackBounds != null) {
			double stackCenterX = stackBounds.x + (stackBounds.w / 2);
			side = stackCenterX < winCenterX ? SideValue.LEFT : SideValue.RIGHT;
		}
		// }

		MTrimBar bar = modelService.getTrim(window, side);
		return bar;
	}

	private String getMinimizedElementSuffix(MUIElement element) {
		String id = ID_SUFFIX;
		MPerspective persp = modelService.getPerspectiveFor(element);
		if (persp != null) {
			id = '(' + persp.getElementId() + ')';
		}
		return id;
	}

	// @Override
	public MTrimBar getTrimBarForMinimizedElement(MUIElement element) {
		MToolBar toolBar = getToolBarForMinimizedElement(element);
		return (MTrimBar) (MElementContainer<?>) toolBar.getParent();
	}

	// @Override
	public MToolBar getToolBarForMinimizedElement(MUIElement element) {
		MTrimmedWindow window = (MTrimmedWindow) getWindowFor(element);
		String trimId = element.getElementId()
				+ getMinimizedElementSuffix(element);
		return (MToolBar) modelService.find(trimId, window);
	}

	// @Override
	public MUIElement getMinimizedParentForPart(MPart part) {
		return part2element.get(part);
	}

	private double parseContainerData(String containerData) {
		if (containerData == null)
			return 0.0d;

		containerData = containerData.trim();

		try {
			return Double.parseDouble(containerData);
		} catch (NumberFormatException e) {
			return 0.0d;
		}
	}

	private Bounds calculateBounds(MUIElement element, MUIElement container,
			Bounds currentBounds) {
		if (container == element) {
			return currentBounds;
		} else if (container instanceof MPartSashContainer) {
			MPartSashContainer sash = (MPartSashContainer) container;

			Map<MPartSashContainerElement, Double> weights = new HashMap<MPartSashContainerElement, Double>();
			double total_weight = 0;
			for (MPartSashContainerElement children : sash.getChildren()) {
				if (children.isToBeRendered() && children.isVisible()
						&& children.getWidget() != null /*
														 * element can be
														 * renderable but has no
														 * widget when removeGui
														 * called for element
														 */) {
					String data = children.getContainerData();
					double weight = parseContainerData(data);

					weights.put(children, weight);
					total_weight += weight;
				}
			}

			if (total_weight == 0.0) // all child elements has zero weight
				total_weight = 1.0;

			double sumWeightPrcnt = 0;
			for (MPartSashContainerElement children : sash.getChildren()) {
				Double w = weights.get(children);
				if (w != null) {
					double wPrcnt = w / total_weight;
					Bounds newBounds;
					if (sash.isHorizontal()) {
						newBounds = new Bounds(currentBounds.x
								+ currentBounds.w * sumWeightPrcnt,
								currentBounds.y, currentBounds.w * wPrcnt,
								currentBounds.h);
					} else {
						newBounds = new Bounds(currentBounds.x, currentBounds.y
								+ currentBounds.h * sumWeightPrcnt,
								currentBounds.w, currentBounds.h * wPrcnt);
					}
					sumWeightPrcnt += wPrcnt;

					Bounds bounds = calculateBounds(element, children,
							newBounds);
					if (bounds != null)
						return bounds;
				}
			}
		} else if (container instanceof MElementContainer<?>) {
			MElementContainer<MUIElement> _container = (MElementContainer<MUIElement>) container;
			for (MUIElement child : _container.getChildren()) {
				Bounds bounds = calculateBounds(element, child, currentBounds);
				if (bounds != null)
					return bounds;
			}
		}

		return null;
	}

}