public static void hideDisplays(final MPartStack displayStack, final List<MPlaceholder> holders) {
	final MElementContainer<MUIElement> parent = displayStack.getParent();
	parent.setVisible(false);
	holders.forEach((ph) -> {
		ph.setVisible(false);
		displayStack.getChildren().add(ph);
	});
	activateDisplays(holders, false);
	for (final MUIElement element : new ArrayList<>(parent.getChildren())) {
		if (element.getTransientData().containsKey(LAYOUT)) {
			element.setVisible(false);
			element.setToBeRendered(false);
			parent.getChildren().remove(element);
		}
	}
}
 

private void save(final MUIElement element, final List<MPlaceholder> holders, final GamaNode<String> parent,
		final String weight) {
	final String data = weight == null ? getWeight(element) : weight;
	if (element instanceof MPlaceholder && holders.contains(element)) {
		parent.addChild(valueOf(element.getTransientData().get(DISPLAY_INDEX_KEY)), parseInt(data));
	} else if (element instanceof MElementContainer) {
		final MElementContainer<?> container = (MElementContainer<?>) element;
		final List<? extends MUIElement> children = getNonEmptyChildren(container, holders);
		if (children.size() == 0) { return; }
		if (children.size() == 1) {
			save(children.get(0), holders, parent, data);
		} else {
			final GamaNode<String> node = parent.addChild(prefix(container), parseInt(data));
			children.forEach(e -> save(e, holders, node, null));
		}
	}
}
 

void switchTo(MPart newPart) {
	if (getOrderedStacks(apart).size() == 1) {
		// case 1: 1 frame, split with miniPart
		// convenience hack: change direction on uArg
		splitIt(newPart, getDirection((isUniversalPresent()) ? !DISPLAY_HORIZONTAL : DISPLAY_HORIZONTAL));
	} else {
		// case 2: multiple stacks, move to adjacent stack
		// get the starting stack
		MElementContainer<MUIElement> stack = getParentStack(apart).getStack();
		// get the topart's stack
		MElementContainer<MUIElement> tstack = getParentStack(newPart).getStack();
		stack = findNextStack(apart, stack, 1);
		if (stack != null && stack != tstack) {
			modelService.move(newPart, stack, 0);
		}
	}
	if (displayOnly) {
		// brings to top
		partService.showPart(newPart, PartState.VISIBLE);
		reactivate(apart);
	} else {
		// bug in Kepler forces us to activate the old before the new
		reactivate(apart);
		reactivate(newPart);
	}
}
 

/**
 * The parent of the apart is typically a PartStack, but it could be something under an MCompositePart, so look up
 * @param apart the original selection
 * @return the MPart and PartStack
 */
protected PartAndStack getParentStack(MPart apart) {
	MPartSashContainerElement part = apart;
	MElementContainer<MUIElement> stack = apart.getParent();
	try {
		while (!((MPartSashContainerElement)stack instanceof MPartStack)) {
			if ((MPartSashContainerElement)stack instanceof MArea) {
				// some unexpected structure
				stack = null;
				part = apart;
				break;
			} else {
				part = (MPartSashContainerElement)stack;
				stack = stack.getParent();
			}
		}
	} catch (Exception e) {
		// Bail on anything unexpected - will just make the command a noop
		stack = null;
		part = apart;
	}
	return new PartAndStack((MPart)part, stack);
}
 

/**
 * Find the first element with which we should join
 * 
 * @param dragStack the stack to join
 * @return the target stack 
 */
@SuppressWarnings("unchecked")  // for safe cast to MElementContainer<MUIElement>
protected MElementContainer<MUIElement> getAdjacentElement(MElementContainer<MUIElement> dragStack, MPart part, boolean stackp) {
	MElementContainer<MUIElement> result = null;
	if (dragStack != null) {
		MElementContainer<MUIElement> psash = dragStack.getParent();
		if ((Object)psash instanceof MPartSashContainer) {
			List<MUIElement> children = psash.getChildren();
			int size = children.size(); 
			if (size > 1) {
				int index = children.indexOf(dragStack)+1;
				// use the next element, or previous if we're the last one
				result = (MElementContainer<MUIElement>)children.get((index == size) ? index - 2 : index);
				if (stackp) {
					result =  findTheStack(result);
				}
			}
		}
	}
	return result;
}
 

/**
 * Find the edit area.  
 * 
 * @param w
 * 
 * @return the MArea element containing the editors
 */
protected MUIElement getEditArea(MWindow w) {
	// Seems like we should be able to use modelService.find(ID_EDITOR_AREA, w), but that returns a useless PlaceHolder
	// NB Selectors aren't supported until Luna
	//		final Selector match = new Selector() {
	//			public boolean select(MApplicationElement element) {
	//				return !modelService.findElements((MUIElement)element, null, MPart.class, EDITOR_TAG, EModelService.IN_ANY_PERSPECTIVE).isEmpty();
	//			}
	//		};
	//		List<MArea> area = modelService.findElements(w, MArea.class, EModelService.IN_SHARED_AREA, match);
	List<MArea> area = modelService.findElements(w, null, MArea.class, null, EModelService.IN_SHARED_AREA);
	List<MArea> refined = new ArrayList<MArea>();
	if (area != null) {
		for (MArea m : area) {
			if (!modelService.findElements(m, null, MPart.class, EDITOR_TAG, EModelService.IN_ANY_PERSPECTIVE).isEmpty()) {
				refined.add(m);
			}
		}
	}
	return refined.isEmpty() ? null : refined.get(0);
}
 

/**
 * @see com.mulgasoft.emacsplus.e4.commands.E4WindowCmd#getAdjacentElement(org.eclipse.e4.ui.model.application.ui.MElementContainer, boolean, org.eclipse.e4.ui.model.application.ui.basic.MPart)
 */
protected MElementContainer<MUIElement> getAdjacentElement(MElementContainer<MUIElement> dragStack, MPart part, boolean stackp) {
	MElementContainer<MUIElement> result = null;
	if (dragStack != null) {
		MElementContainer<MUIElement> psash = dragStack.getParent();
		MElementContainer<MUIElement> top = getTopElement(psash);
		if ((Object)top instanceof MTrimmedWindow) {
			// if we contain splits, remove them first
			if (top != psash) {
				super.joinAll(part);
			}
			Collection<MPart> parts = getParts(application.getChildren().get(0), EModelService.IN_SHARED_AREA);
			for (MPart p : parts) {
				List<MElementContainer<MUIElement>> all = getOrderedStacks(p);
				// if it has a PartStack, it sh/c/ould be an editor stack
				if (!all.isEmpty()) {
					result = all.get(0);
					break;
				};
			};
		}
	}
	return result;
}
 

/**
 * Merge the stack containing the selected part into its neighbor and return the 
 * element to activate.  This will be the originating buffer on split-self or the
 * active element in the other stack if not.
 * 
 * @param apart
 * @return the element to select
 */
MPart joinOne(MPart apart) {
	// We're going to end up with 1, so avoid the overhead of futzing with the stacks
	if (isSplitSelf() && getOrderedStacks(apart).size() < 3) {
		this.joinAll(apart);
		return apart;
	} else {
		PartAndStack ps = getParentStack(apart);
		MElementContainer<MUIElement> pstack = ps.getStack();
		MPart part = ps.getPart();		
		MElementContainer<MUIElement> adjacent = getAdjacentElement(pstack, part, true);
		MUIElement otherPart = getSelected(adjacent);
		// deduplicate editors across these two stacks
		closeOthers(pstack, adjacent);
		if (pstack == null || join2Stacks(pstack, adjacent, part) == null) {
			// Invalid state 
			Beeper.beep();
		}
		return (otherPart instanceof MPart) ? (MPart)otherPart : apart;
	}
}
 

/**
 * Get all the IEditorReferences in a given part stack
 * 
 * @param stack
 * @return the collection of IEditorReferences
 */
private Collection<IEditorReference> getStackEditors(MElementContainer<MUIElement> stack) {
	Collection<IEditorReference> editors = new ArrayList<IEditorReference>(); 
	for (MUIElement child : stack.getChildren()) {
		if (child instanceof MPart) {
			// TODO: There must be a better way of getting the editor out of e4, but I can't find it
			Object cEditor = ((MPart) child).getObject();
			if (cEditor != null) {
				try {
					// avoid discouraged access of org.eclipse.ui.internal.e4.compatibility.CompatibilityEditor
					// which is expected cEditor's type in e4
					Method method = cEditor.getClass().getMethod(GET_REF);
					if (method != null) {
						IEditorReference ie = (IEditorReference)method.invoke(cEditor);					
						editors.add(ie);

					}
				} catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException
						| InvocationTargetException | ClassCastException e) {

				}
			}
		}
	}
	return editors;
}
 

@Execute
protected void doOtherWindow(@Active MPart apart, @Named(E4CmdHandler.CMD_CTX_KEY)String cmd, @Active EmacsPlusCmdHandler handler) {
	PartAndStack ps = getParentStack(apart); 
	MElementContainer<MUIElement> otherStack = getAdjacentElement(ps.getStack(), ps.getPart(), true);
	MPart other = (MPart)otherStack.getSelectedElement();
	// TODO An egregious hack that may break at any time
	// Is there a defined way of getting the IEditorPart from an MPart?
	if (other.getObject() instanceof CompatibilityEditor) {
		IEditorPart editor = ((CompatibilityEditor) other.getObject()).getEditor();
		try {
			reactivate(other);
			if (handler.isUniversalPresent()) {
				EmacsPlusUtils.executeCommand(cmd, handler.getUniversalCount(), null, editor);
			} else {
				EmacsPlusUtils.executeCommand(cmd, null, editor);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		finally {
			reactivate(apart);
		}
	}
}
 

/**
 * well, this goes to the renderer.
 *
 * @param mgr
 */
public void addMenuContributions(IMenuManager mgr) {
    IRendererFactory factory = modelPart.getContext().get(IRendererFactory.class);
    AbstractPartRenderer obj = factory.getRenderer(menuModel, null);
    if (obj instanceof MenuManagerRenderer) {
        MenuManagerRenderer renderer = (MenuManagerRenderer) obj;
        renderer.reconcileManagerToModel(menu, menuModel);
        renderer.processContributions(menuModel, menuModel.getElementId(), false, true);
        // double cast because we're bad people
        renderer.processContents((MElementContainer<MUIElement>) ((Object) menuModel));
        List<MMenuElement> toRemove = new ArrayList<>();
        for (MMenuElement e : menuModel.getChildren()) {
            if (!(e instanceof MMenuSeparator || INCLUDES.contains(e.getElementId())
                    || e.getElementId() == null)) {
                if (e.getElementId() != null && !e.getElementId().startsWith("org.bonitasoft.studio.")) {
                    toRemove.add(e);
                    e.setVisible(false);
                }
            }
        }
        menuModel.getChildren().removeAll(toRemove);
    }

}
 

String getWeight(final MUIElement element) {
	String data = element.getContainerData();
	final MUIElement parent = element.getParent();
	while (data == null && parent != null) {
		data = parent.getContainerData();
	}
	return data;
}
 

public static void showBottomTray(final WorkbenchWindow window, final Boolean show) {

		final MUIElement trimStatus = getTrimStatus(window);
		if ( trimStatus != null ) {
			// toggle statusbar visibility
			trimStatus.setVisible(show);
		}

	}
 

@Execute
public void execute(EModelService modelService, EPartService partService,
		MWindow window,
		@Named("com.vogella.rcp.jface.translation.commandparameter.perspectiveid") String id) {
	MPerspective activePerspective = modelService
			.getActivePerspective(window);


	MUIElement find = modelService.find(id, window);
	if (find == null || activePerspective.equals(find)) {
		return;
	}

	partService.switchPerspective((MPerspective) find);
}
 

@Execute
public void execute(EModelService modelService, MWindow window, EPartService partService) {

	// get active perpective and find stored snippet of this perspective
	MPerspective activePerspective = modelService.getActivePerspective(window);
	MUIElement perspectiveSnippet = modelService.cloneSnippet(window, activePerspective.getElementId(), window);

	// remove existing active perspective
	MElementContainer<MUIElement> parent = activePerspective.getParent();
	modelService.removePerspectiveModel(activePerspective, window);

	// add stored perspective snippet and switch to it
	parent.getChildren().add(perspectiveSnippet);
	partService.switchPerspective((MPerspective) perspectiveSnippet);
}
 

@Execute
public Object execute(@Active MPart apart, @Active IEditorPart editor, @Active MWindow mwin, @Active EmacsPlusCmdHandler handler) {

	try {
		this.apart = apart;
		this.handler = handler;
		Command ex = getOpenCmd(editor);
		if (ex != null) {
			MUIElement area = getEditArea(application.getChildren().get(0));
			MUIElement osel = getSelected(area);
			EmacsPlusUtils.executeCommand(ex.getId(), null);
			MUIElement sel = getSelected(area);
			// see if it was able to open a declaration
			if (sel instanceof MPart && sel != apart && sel != osel) {
				// another way of determining if we're main or frame
				if (!mwin.getTags().contains(TOP_TAG) && !handler.isUniversalPresent()) {
					// If they're in different frames, move copy to source frame first
					modelService.move(sel, getParentStack(apart).getStack(), 0);
				};
				switchTo((MPart)sel);
			}
		}
	} catch (Exception e) {
		// Shouldn't happen
		Beeper.beep();
	}
	return null;
}
 

@Execute
public Object execute(@Active MPart apart,  @Named(E4CmdHandler.CMD_CTX_KEY)Col stype, @Active EmacsPlusCmdHandler handler) {
	PartAndStack ps = getParentStack(apart);
	MElementContainer<MUIElement> stack = ps.getStack();
	MElementContainer<MUIElement> next = getAdjacentElement(stack, ps.getPart(), false);
	
	int count = handler.getUniversalCount();
	// if we have an adjacent part, we're in a sash
	if (next != null) {
		switch (stype) {
		case SHRINK:
			adjustContainerData((MUIElement)stack, (MUIElement)next, count, getTotalSize(apart));
			break;
		case ENLARGE:
			adjustContainerData((MUIElement)next, (MUIElement)stack, count, getTotalSize(apart));
			break;
		case BALANCE:
			balancePartSash(stack);
			break;
		}
		// For some reason, in recent eclipses, we have to request the layout manually
           Object widget = stack.getWidget();
           // Double check before grabbing the parent composite for looping 
		if (widget instanceof CTabFolder) {
			// this is apparently the recommended way of getting these to redraw properly
			for (Control c : ((Composite)widget).getParent().getChildren()) {
				c.requestLayout();
			}
		}
	}	
	return null;
}
 

/**
 * Change the size of from relative to to by amount, but do not go below
 * a minimum size.
 * 
 * @param from selected PartStack
 * @param to adjacent PartStack
 * @param amount by which to adjust each
 */
private void adjustContainerData(MUIElement from, MUIElement to, int count, int size) {
	int adjust = getIntData(from);;
	int adjustTo = getIntData(to);;
	int amount = (Math.round(size * adjustment)) * count;
	int minim = Math.round(size * minsize);
	if (adjust - amount < minim) {
		// enforce minimum size					
		amount = adjust - minim;
	}
	// take from the rich and give to the poor
	from.setContainerData(String.valueOf(adjust - amount));
	to.setContainerData(String.valueOf(adjustTo + amount));
}
 

/**
 * Get the ordered list of stacks
 * @param apart
 * @return a list of MElementContainer<MUIElement> representing all the PartStacks
 */
protected List<MElementContainer<MUIElement>> getOrderedStacks(MPart apart) {
	List<MElementContainer<MUIElement>> result = new ArrayList<MElementContainer<MUIElement>>();
	MElementContainer<MUIElement> parent = getTopElement(apart.getParent());
	if (parent != null) {
		result = getStacks(result, parent);
	} 
	return result;
}
 

private List<MElementContainer<MUIElement>> getStacks(List<MElementContainer<MUIElement>> result, MElementContainer<MUIElement> container) {
	for (MUIElement child : container.getChildren()) {
		@SuppressWarnings("unchecked") // We type check all the way down
		MElementContainer<MUIElement> c = (MElementContainer<MUIElement>)child;
		if (child instanceof MPartStack) {
			result.add(c);
		} else {
			getStacks(result,c);
		}
	}
	return result;
}
 

/**
 * If parent is a sash, keep looking until we find a PartStack
 * 
 * @param parent a sash of PartStack
 * @return the first PartStack we find
 */
@SuppressWarnings("unchecked")  // for safe cast to MElementContainer<MUIElement>
private MElementContainer<MUIElement> findTheStack(MElementContainer<MUIElement> parent) {
	MElementContainer<MUIElement> result = parent;
	if ((MPartSashContainerElement)parent instanceof MPartSashContainer) {
		List<MUIElement> children = parent.getChildren();
		result = findTheStack((MElementContainer<MUIElement>)children.get(0));
	}
	return result;
}
 

/**
 * Rotate through stacks by <count> elements
 *  
 * @param part the source part
 * @param stack the source stack
 * @param count the number to rotate by
 * @return the destination stack
 */
protected MElementContainer<MUIElement> findNextStack(MPart part, MElementContainer<MUIElement> stack, int count) {
	MElementContainer<MUIElement> nstack = null;		
	List<MElementContainer<MUIElement>> stacks = getOrderedStacks(part);		
	int size = stacks.size();
	if (size > 1) {
		int index = stacks.indexOf(stack) + (count % size);
		nstack = (index < 0) ? stacks.get(size + index) : (index < size) ? stacks.get(index) : stacks.get(index - size); 
	}
	return nstack;
}
 

/**
 * @param ele start from here
 * @return the most distant parent for the editor area
 */
protected MElementContainer<MUIElement> getTopElement(MElementContainer<MUIElement> ele) {
	MElementContainer<MUIElement> parent = ele;
	// get the outer container
	if (parent != null) {
		while (!((Object)parent instanceof MArea) && parent.getParent() != null) {
				parent = parent.getParent();
		}
	}
	return parent;
}
 

protected int getTotalSize(MPart apart) {
	int result = 0;
	List<MUIElement> topParts = getTopElement(apart.getParent()).getChildren();
	for (MUIElement mui : topParts) {
		result += sizeIt(mui);
	}
	return (result == 0 ? TOTAL_SIZE : result);
}
 

private int sizeIt(MUIElement ele) {
	int result = 0;
	if (ele.getContainerData() != null) {
		result = getIntData(ele);
	} else if (ele instanceof MElementContainer) {
		@SuppressWarnings("unchecked") //checked
		List<MUIElement> mlist = ((MElementContainer<MUIElement>)ele).getChildren();
		for (MUIElement mui : mlist) {
			result += sizeIt(mui);
		}
	}
	return result;
}
 

protected int getIntData(MUIElement mui) {
	try {
		return Integer.parseInt(mui.getContainerData());
	} catch (NumberFormatException e) {
		// Ignore - someone has messed with the container data
		return 0;
	}
}
 

@SuppressWarnings("unchecked") // manually checked
MUIElement getSelected(MUIElement ele) {
 	MUIElement sel = ele;
	while (sel instanceof MElementContainer) {
		sel = ((MElementContainer<MUIElement>)sel).getSelectedElement();
	}
	// on occasion the above returns null which is bizarre, so try skipping the first level
	if (sel == null && ele instanceof MElementContainer) {
		List<MUIElement> c = ((MElementContainer<MUIElement>)ele).getChildren();
		if (c.size() == 1 && c.get(0) instanceof MPartStack) {
			sel = ((MElementContainer<MUIElement>)c.get(0)).getSelectedElement();
		}
	}
	return sel;
}
 

protected void splitIt(MPart apart, int location) {
	PartAndStack ps = getParentStack(apart);
	MElementContainer<MUIElement> pstack = ps.getStack();
	if (pstack.getChildren().size() > 1) {
		MPart newpart = ps.getPart();		

		MPartStack nstack = getStack(newpart, pstack);
		// Let the model service take care of the rest of the split
		modelService.insert(nstack, (MPartSashContainerElement)pstack, location, ratio);
	}
}
 

/**
 * Wrap the editor (MPart) up in a new PartStack
 * @param apart
 * @return the wrapped MPart
 */
private MPartStack getStack(MPart apart, MElementContainer<MUIElement> parent) {
	MPartStack result = MBasicFactory.INSTANCE.createPartStack();
	MStackElement stackElement = (MStackElement) apart;
	parent.getChildren().remove(apart);
	result.getChildren().add(stackElement);
	result.setSelectedElement(stackElement);
	return result;
}
 

@Override
void joinAll(MPart apart) {
	joined = true;
	List<MTrimmedWindow> frames = getDetachedFrames();
	MElementContainer<MUIElement> last = getTopElement((MElementContainer<MUIElement>) apart.getParent());
	for (MTrimmedWindow mt : frames) {
		if (!mt.equals(last)) {
			joinOne(mt);
		}
	}
	// only join apart if its top element is a frame
	if ((Object)last instanceof MTrimmedWindow) {
		super.joinOne(apart);
	}
}