import org.eclipse.e4.ui.model.application.ui.MElementContainer; //导入依赖的package包/类
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);
	}
}
 

import org.eclipse.e4.ui.model.application.ui.MElementContainer; //导入依赖的package包/类
@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 (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;
		}
	}	
	return null;
}
 

import org.eclipse.e4.ui.model.application.ui.MElementContainer; //导入依赖的package包/类
/**
 * 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;
				result = (MElementContainer<MUIElement>)children.get((index == size) ? index - 2 : index);
				if (stackp) {
					result =  findTheStack(result);
				}
			}
		}
	}
	return result;
}
 

import org.eclipse.e4.ui.model.application.ui.MElementContainer; //导入依赖的package包/类
/**
 * @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;
}
 

import org.eclipse.e4.ui.model.application.ui.MElementContainer; //导入依赖的package包/类
@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);
		}
	}
}
 

import org.eclipse.e4.ui.model.application.ui.MElementContainer; //导入依赖的package包/类
/**
 * Save db settings and browser state to preferences.
 *
 * @param inApplication
 *            {@link MApplication}
 */
@SuppressWarnings("unchecked")
@PreDestroy
void saveApp(final MApplication inApplication,
        final EModelService inModelService) {
	// save browser id
	final MElementContainer<MUIElement> lBrowserStack = (MElementContainer<MUIElement>) inModelService
	        .find(RelationsConstants.PART_STACK_BROWSERS, inApplication);
	final MUIElement lBrowser = lBrowserStack.getSelectedElement();
	preferences.put(RelationsConstants.ACTIVE_BROWSER_ID,
	        lBrowser.getElementId());

	// save browser model
	browserManager.saveState(preferences);
	// flush preferences
	try {
		preferences.flush();
	}
	catch (final BackingStoreException exc) {
		log.error(exc, exc.getMessage());
	}
}
 

import org.eclipse.e4.ui.model.application.ui.MElementContainer; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public static <T extends MUIElement> List<T> getMatchingChildren(MElementContainer<?> container, Class<T> type) {
	List<T> matchingChildren = new ArrayList<T>();
	
	for (Object child : container.getChildren()) {
		if (type.isInstance(child))
			matchingChildren.add((T) child);
	}		
	
	return matchingChildren;
}
 

import org.eclipse.e4.ui.model.application.ui.MElementContainer; //导入依赖的package包/类
/**
 * Recursively sets the active selection to the element until it reaches the 
 * containing window.
 * 
 * @param element the new selected element
 */
public static void setWindowSelectedElement(MUIElement element) {
	MElementContainer<MUIElement> parent = element.getParent();
	parent.setSelectedElement(element);
	if (!((MUIElement) parent instanceof MWindow))
		setWindowSelectedElement(parent);
}
 

import org.eclipse.e4.ui.model.application.ui.MElementContainer; //导入依赖的package包/类
/**
 * Recursively checks if the active selection of the parent is the <tt>element</tt>, 
 * until the containing window element is reached. Returns true if the selected
 * element is the parameter in the window and false otherwise.
 *  
 * @param element the model element to check
 * @return true if the model element is the selected element 
 * 			false otherwise
 */
public static boolean isSelectedElement(MUIElement element) {
	MElementContainer<MUIElement> parent = element.getParent();
	if (parent.getSelectedElement() == element) {
		if (!((MUIElement) parent instanceof MWindow))
			return isSelectedElement(parent);
		else
			return true;
	}	
	
	return false;
}
 

import org.eclipse.e4.ui.model.application.ui.MElementContainer; //导入依赖的package包/类
static void grid(final MPartStack displayStack, final List<MPlaceholder> holders) {
	final MElementContainer currentSash = displayStack.getParent();
	final int size = holders.size();
	final List<MElementContainer> containers = new ArrayList<>();
	createContainers(currentSash, containers, size, true);
	for (int i = 0; i < holders.size(); i++) {
		associate(containers.get(i), holders.get(i), false);
	}
}
 

import org.eclipse.e4.ui.model.application.ui.MElementContainer; //导入依赖的package包/类
static void horizontalOrVertical(final MPartStack displayStack, final List<MPlaceholder> holders,
		final boolean horizontal) {
	final MElementContainer rootSash = displayStack.getParent();
	((MPartSashContainer) rootSash).setHorizontal(horizontal);
	for (int i = 0; i < holders.size(); i++) {
		associate(createContainer(rootSash), holders.get(i), false);
	}
}
 

import org.eclipse.e4.ui.model.application.ui.MElementContainer; //导入依赖的package包/类
private static void createContainers(final MElementContainer root, final List<MElementContainer> containers,
		final int size, final boolean horizontal) {
	((MPartSashContainer) root).setHorizontal(horizontal);
	if (size == 0)
		return;
	else if (size == 1) {
		final MElementContainer container = createContainer(root);
		containers.add(container);
	} else {
		final int half = size / 2;
		createContainers(createSash(root), containers, half, !horizontal);
		createContainers(createSash(root), containers, size - half, !horizontal);
	}
}
 

import org.eclipse.e4.ui.model.application.ui.MElementContainer; //导入依赖的package包/类
static MPartSashContainer createSash(final MElementContainer root) {
	final MPartSashContainer sash = modelService.createModelElement(MPartSashContainer.class);
	sash.getTransientData().put("Dynamic", true);
	sash.setContainerData("5000");
	root.getChildren().add(sash);
	return sash;
}
 

import org.eclipse.e4.ui.model.application.ui.MElementContainer; //导入依赖的package包/类
static MPartStack createStack(final MElementContainer root) {
	final MPartStack stack = modelService.createModelElement(MPartStack.class);
	stack.getTransientData().put("Dynamic", true);
	stack.setContainerData("5000");
	root.getChildren().add(stack);
	return stack;
}
 

import org.eclipse.e4.ui.model.application.ui.MElementContainer; //导入依赖的package包/类
@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);
}
 

import org.eclipse.e4.ui.model.application.ui.MElementContainer; //导入依赖的package包/类
/**
 * 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;
}
 

import org.eclipse.e4.ui.model.application.ui.MElementContainer; //导入依赖的package包/类
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;
}
 

import org.eclipse.e4.ui.model.application.ui.MElementContainer; //导入依赖的package包/类
/**
 * 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;
}
 

import org.eclipse.e4.ui.model.application.ui.MElementContainer; //导入依赖的package包/类
/**
 * 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;
}
 

import org.eclipse.e4.ui.model.application.ui.MElementContainer; //导入依赖的package包/类
/**
 * @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;
}