@Override public boolean isPartVisible(MPart part) { if (isInContainer(part)) { MUIElement element = part; MElementContainer<?> parent = part.getParent(); if (parent == null) { // might be a shared part element = part.getCurSharedRef(); if (element == null) { return false; } parent = element.getParent(); if (parent == null) { return false; } } if (parent instanceof MPartStack) { return parent.getSelectedElement() == element; } return element.isVisible(); } return false; }
/* * (non-Javadoc) * * @see * org.eclipse.e4.ui.workbench.renderers.swt.SWTPartRenderer#processContents * (org.eclipse.e4.ui.model.application.ui.MElementContainer) */ @Override public void processContents(MElementContainer<MUIElement> container) { // I can either simply stop processing, or we can walk the model // ourselves like the "old" days // EMF gives us null lists if empty if (container == null) return; Object obj = container; ToolBarManager parentManager = getManager((MToolBar) obj); if (parentManager == null) { return; } // Process any contents of the newly created ME List<MUIElement> parts = container.getChildren(); if (parts != null) { MUIElement[] plist = parts.toArray(new MUIElement[parts.size()]); for (int i = 0; i < plist.length; i++) { MUIElement childME = plist[i]; modelProcessSwitch(parentManager, (MToolBarElement) childME); } } parentManager.update(true); ToolBar tb = getToolbarFrom(container.getWidget()); if (tb != null) { tb.pack(true); tb.getShell().layout(new Control[] {tb}, SWT.DEFER); } }
private MElementContainer<? extends MUIElement> getLastContainer() { MElementContainer<? extends MUIElement> searchRoot = getContainer(); @SuppressWarnings("unchecked") List<MUIElement> children = (List<MUIElement>) searchRoot.getChildren(); if (children.size() == 0) { MPartStack stack = modelService.createModelElement(MPartStack.class); children.add(stack); return stack; } MElementContainer<?> lastContainer = getLastContainer(searchRoot, children); if (lastContainer instanceof MPartStack) { return lastContainer; } // No stacks found make one and add it MPartStack stack = modelService.createModelElement(MPartStack.class); stack.setElementId("CreatedByGetLastContainer"); // $NON-NLS-1$ if (children.get(0) instanceof MPartSashContainer) { MPartSashContainer psc = (MPartSashContainer) children.get(0); psc.getChildren().add(stack); } else { // We need a sash so 'insert' the new stack modelService.insert( stack, (MPartSashContainerElement) children.get(0), EModelService.RIGHT_OF, 0.5f); } return stack; }
@Override public int countRenderableChildren(MUIElement element) { if (!(element instanceof MElementContainer<?>)) { return 0; } @SuppressWarnings("unchecked") MElementContainer<MUIElement> container = (MElementContainer<MUIElement>) element; int count = 0; List<MUIElement> kids = container.getChildren(); for (MUIElement kid : kids) { if (kid.isToBeRendered()) { count++; } } if (element instanceof MPerspective) { MPerspective perspective = (MPerspective) element; for (MWindow window : perspective.getWindows()) { if (window.isToBeRendered()) { count++; } } } return count; }
private void combine( MPartSashContainerElement toInsert, MPartSashContainerElement relTo, MPartSashContainer newSash, boolean newFirst, float ratio) { MElementContainer<MUIElement> curParent = relTo.getParent(); if (curParent == null) { // if relTo is a shared element, use its current placeholder MWindow win = getTopLevelWindowFor(relTo); relTo = findPlaceholderFor(win, relTo); curParent = relTo.getParent(); } Assert.isLegal(relTo != null && curParent != null); int index = curParent.getChildren().indexOf(relTo); curParent.getChildren().remove(relTo); if (newFirst) { newSash.getChildren().add(toInsert); newSash.getChildren().add(relTo); } else { newSash.getChildren().add(relTo); newSash.getChildren().add(toInsert); } // Set up the container data before adding the new sash to the model // To raise the granularity assume 100% == 10,000 int adjustedPct = (int) (ratio * 10000); toInsert.setContainerData(Integer.toString(adjustedPct)); relTo.setContainerData(Integer.toString(10000 - adjustedPct)); // add the new sash at the same location curParent.getChildren().add(index, newSash); }
private static int getIndex(MElementContainer<?> menuModel, String positionInParent) { String id = null; String modifier = null; if (positionInParent != null && positionInParent.length() > 0) { String[] array = positionInParent.split("="); // $NON-NLS-1$ modifier = array[0]; // may have an invalid position, check for this if (array.length > 1) { id = array[1]; } } if (id == null) { return menuModel.getChildren().size(); } int idx = 0; int size = menuModel.getChildren().size(); while (idx < size) { if (id.equals(menuModel.getChildren().get(idx).getElementId())) { if ("after".equals(modifier)) { // $NON-NLS-1$ idx++; } return idx; } idx++; } return id.equals("additions") ? menuModel.getChildren().size() : -1; // $NON-NLS-1$ }
// ------------------------------------------------------- // ------------------------------------------------------- private void hideElementRecursive(MUIElement element) { if (element == null || element.getWidget() == null) return; if (element instanceof MPlaceholder) { MPlaceholder ph = (MPlaceholder) element; element = ph.getRef(); } // Hide any floating windows if (element instanceof MWindow && element.getWidget() != null) { element.setVisible(false); } if (element instanceof MElementContainer<?>) { MElementContainer<?> container = (MElementContainer<?>) element; for (MUIElement childElement : container.getChildren()) { hideElementRecursive(childElement); } // OK, now process detached windows if (element instanceof MWindow) { for (MWindow w : ((MWindow) element).getWindows()) { hideElementRecursive(w); } } else if (element instanceof MPerspective) { for (MWindow w : ((MPerspective) element).getWindows()) { hideElementRecursive(w); } } } }
private MContext getParentWithContext(MUIElement part) { MElementContainer<MUIElement> parent = part.getParent(); MUIElement intermediate = parent; if (intermediate == null) { intermediate = part; } else { while (parent != null) { if (parent instanceof MContext) { if (((MContext) parent).getContext() != null) return (MContext) parent; } intermediate = parent; parent = parent.getParent(); } } MPlaceholder placeholder = modelService.findPlaceholderFor(getWindow(), intermediate); parent = placeholder.getParent(); while (parent != null) { if (parent instanceof MContext) { if (((MContext) parent).getContext() != null) return (MContext) parent; } parent = parent.getParent(); } return null; }
protected Command computeCommand() { MUIElement selectedPart = model; if (selectedPart instanceof MPart) { MGenericStack<MUIElement> partStack = findParentStack(); if (partStack != null) { selectedPart = partStack; } } MElementContainer<MUIElement> parent = partStack.getParent(); List<MUIElement> children = parent.getChildren(); int index = children.indexOf(partStack); if (parent instanceof MGenericTile<?>) { MGenericTile<?> genericTile = (MGenericTile<?>) parent; int modelIndex = children.indexOf(selectedPart); if (modelIndex == 0 && index == 1 && children.size() == 2 && genericTile.isHorizontal()) { return UnexecutableCommand.INSTANCE; } } CompoundCommand result = new CompoundCommand(); MPartSashContainer newSash = MBasicFactory.INSTANCE.createPartSashContainer(); String preferData = partStack.getContainerData(); newSash.setContainerData(preferData); newSash.setHorizontal(true); if (selectedPart instanceof MPartStack) { if (selectedPart.getParent() == null) { selectedPart.setContainerData(preferData); result.add(CommandFactory.createAddChildCommand(newSash, selectedPart, 0)); } else { result.add(new ChangeParentCommand(newSash, selectedPart, 0)); if (!preferData.equals(selectedPart.getContainerData())) { result.add( new ApplyAttributeSettingCommand( (EObject) selectedPart, "containerData", preferData)); } } } else if (selectedPart instanceof MPart) { MPart part = (MPart) selectedPart; MPartStack createPartStack = MBasicFactory.INSTANCE.createPartStack(); createPartStack.setContainerData(preferData); if (part.getParent() != null) { result.add(new ChangeParentCommand(createPartStack, part, 0)); } else { result.add(CommandFactory.createAddChildCommand(createPartStack, part, 0)); } result.add(CommandFactory.createAddChildCommand(newSash, createPartStack, 0)); } result.add(new ChangeParentCommand(newSash, partStack, 1)); result.add(CommandFactory.createAddChildCommand(parent, newSash, index)); return result.unwrap(); }
private void exchange_editor_with_selected_in_new_stack( MPart activeEditor, MElementContainer<MUIElement> oldEditorStack, MElementContainer<MUIElement> newStack) { int activeEditorIndex = oldEditorStack.getChildren().indexOf(activeEditor); MUIElement exchangedEditor = newStack.getSelectedElement(); int exchangedEditorIndex = newStack.getChildren().indexOf(exchangedEditor); oldEditorStack.getChildren().add(activeEditorIndex, exchangedEditor); newStack.getChildren().add(exchangedEditorIndex, activeEditor); }
/** @param parent */ private void setStackVisibility(MElementContainer<MUIElement> parent) { for (MUIElement child : parent.getChildren()) { if (child.isToBeRendered() && child.isVisible()) { parent.setToBeRendered(true); return; } } parent.setToBeRendered(false); // continue modifying the visibility as the parent's parent may also // need to be hidden from the user setStackVisibility(parent.getParent()); }
private MElementContainer<MUIElement> findContainer( MElementContainer<MUIElement> container, MUIElement element) { for (MUIElement child : container.getChildren()) { if (child == element) { return container; } else if (child instanceof MPlaceholder) { MPlaceholder placeholder = (MPlaceholder) child; MUIElement ref = placeholder.getRef(); if (ref == element) { return container; } else if (ref instanceof MElementContainer<?>) { @SuppressWarnings("unchecked") MElementContainer<MUIElement> ref2 = (MElementContainer<MUIElement>) ref; MElementContainer<MUIElement> match = findContainer(ref2, element); if (match != null) { return match; } } } else if (child instanceof MElementContainer<?>) { @SuppressWarnings("unchecked") MElementContainer<MUIElement> child2 = (MElementContainer<MUIElement>) child; MElementContainer<MUIElement> match = findContainer(child2, element); if (match != null) { return match; } } } return null; }
@Override public void processContents(MElementContainer<MUIElement> element) { if (!(((MUIElement) element) instanceof MWindow)) { return; } MWindow mWindow = (MWindow) ((MUIElement) element); Shell shell = (Shell) element.getWidget(); // Populate the main menu IPresentationEngine2 renderer = (IPresentationEngine2) context.get(IPresentationEngine.class.getName()); if (mWindow.getMainMenu() != null) { renderer.createGui(mWindow.getMainMenu(), element); shell.setMenuBar((Menu) mWindow.getMainMenu().getWidget()); } // create Detached Windows for (MWindow dw : mWindow.getWindows()) { renderer.createGui(dw, element); } // Populate the trim (if any) if (mWindow instanceof MTrimmedWindow) { MTrimmedWindow tWindow = (MTrimmedWindow) mWindow; for (MTrimBar trimBar : tWindow.getTrimBars()) { renderer.createGui(trimBar, element); } } shell.pack(); shell.open(); }
private void addToManager( MenuManager parentManager, MMenuElement model, IContributionItem menuManager) { MElementContainer<MUIElement> parent = model.getParent(); // technically this shouldn't happen if (parent == null) { parentManager.add(menuManager); } else { int index = parent.getChildren().indexOf(model); // shouldn't be -1, but better safe than sorry if (index > parentManager.getSize() || index == -1) { parentManager.add(menuManager); } else { parentManager.insert(index, menuManager); } } }
public static int getPositionIndex( String positionInList, MElementContainer<MUIElement> container) { if (positionInList == null || positionInList.trim().length() == 0) { return -1; } PositionInfo posInfo = PositionInfo.parse(positionInList); if (posInfo == null) { return -1; } switch (posInfo.getPosition()) { case FIRST: return 0; case INDEX: return posInfo.getPositionReferenceAsInteger(); case BEFORE: case AFTER: String elementId = posInfo.getPositionReference(); List<MUIElement> siblings = container.getChildren(); for (int i = 0; i < siblings.size(); i++) { MUIElement sibling = siblings.get(i); if (elementId.equals(sibling.getElementId())) { return posInfo.getPosition() == Position.BEFORE ? i : i + 1; } } case LAST: default: return -1; } }
@Override public void processContents(MElementContainer<MUIElement> container) { IPresentationEngine renderer = (IPresentationEngine) context.get(IPresentationEngine.class.getName()); ToolBar toolbar = (ToolBar) container.getWidget(); boolean isFirst = true; for (MUIElement element : container.getChildren()) { Node node = (Node) renderer.createGui(element); if (node != null) { if (!isFirst) { toolbar.getItems().add(new Separator()); } toolbar.getItems().add(node); isFirst = false; } } }
@Override public int toBeRenderedCount(MElementContainer<?> container) { int count = 0; for (MUIElement child : container.getChildren()) { if (child.isToBeRendered()) { count++; } } return count; }
private MElementContainer<? extends MUIElement> getLastContainer( MElementContainer<?> container, List<?> children) { if (children.isEmpty()) { return null; } for (int i = children.size() - 1; i > -1; i--) { Object muiElement = children.get(i); if (muiElement instanceof MElementContainer<?>) { MElementContainer<?> childContainer = (MElementContainer<?>) muiElement; MElementContainer<?> lastContainer = getLastContainer(childContainer, childContainer.getChildren()); if (lastContainer != null) { return lastContainer; } } } return container; }
private void addToLastContainer(String category, MPart part) { // OK, we haven't found an explicit placeholder; // If this is a multi-instance view see if there's a 'global' placeholder String partId = part.getElementId(); int colonIndex = partId == null ? -1 : partId.indexOf(':'); if (colonIndex >= 0) { String descId = part.getElementId().substring(0, colonIndex); descId += ":*"; // $NON-NLS-1$ List<MPlaceholder> phList = modelService.findElements( workbenchWindow, descId, MPlaceholder.class, null, EModelService.PRESENTATION); if (phList.size() > 0) { MUIElement phParent = phList.get(0).getParent(); if (phParent instanceof MPartStack) { MPartStack theStack = (MPartStack) phParent; int phIndex = theStack.getChildren().indexOf(phList.get(0)); adjustPlaceholder(part); MPlaceholder placeholder = part.getCurSharedRef(); if (placeholder == null) { theStack.getChildren().add(phIndex, part); } else { theStack.getChildren().add(phIndex, placeholder); } return; } } } @SuppressWarnings("unchecked") MElementContainer<MUIElement> lastContainer = (MElementContainer<MUIElement>) getLastContainer(); MPlaceholder placeholder = part.getCurSharedRef(); if (placeholder == null) { lastContainer.getChildren().add(part); } else { lastContainer.getChildren().add(placeholder); } if (category != null) { lastContainer.getTags().add(category); } }
/** * Records the specified parent 's selected element in the activation history. * * @param parent the element whose selected element should be checked for activation history * recording */ private void recordSelectedActivation(MElementContainer<? extends MUIElement> parent) { MUIElement selectedElement = parent.getSelectedElement(); if (selectedElement instanceof MPart) { partActivationHistory.append((MPart) selectedElement); } else if (selectedElement instanceof MPlaceholder) { MUIElement ref = ((MPlaceholder) selectedElement).getRef(); if (ref instanceof MPart) { partActivationHistory.append((MPart) ref); } } }
@Override public <T extends MUIElement> void move( T element, MElementContainer<? super T> newParent, int index, boolean leavePlaceholder) { // Cache where we were MElementContainer<MUIElement> curParent = element.getParent(); int curIndex = curParent.getChildren().indexOf(element); // Move the model element if (index == -1) { newParent.getChildren().add(element); } else { newParent.getChildren().add(index, element); } if (leavePlaceholder) { MPlaceholder ph = MAdvancedFactory.INSTANCE.createPlaceholder(); ph.setRef(element); curParent.getChildren().add(curIndex, ph); } }
/** * "Container" here is: 1) a selected MPerspective, or, if none available 2) the MWindow for which * this part service is created, or, if not available, 3) the MApplication. */ private MElementContainer<? extends MUIElement> getContainer() { MElementContainer<? extends MUIElement> outerContainer = (workbenchWindow != null) ? workbenchWindow : application; // see if we can narrow it down to the active perspective for (MElementContainer<? extends MUIElement> container = outerContainer; container != null; ) { if (container instanceof MPerspective) { return container; } Object child = container.getSelectedElement(); if (child == null) { break; } if (child instanceof MElementContainer<?>) { container = (MElementContainer<?>) child; } else { break; } } return outerContainer; }
@Override public void bringToTop(MPart part) { if (isInContainer(part)) { MUIElement currentElement = part; MElementContainer<MUIElement> parent = part.getParent(); if (parent == null) { currentElement = modelService.findPlaceholderFor(getWindow(), part); parent = currentElement.getParent(); } // If the part is in the same stack as the currently active part then activate it // instead MElementContainer<MUIElement> activeParent = activePart != null ? activePart.getParent() : null; if (activePart != null && activeParent == null) { MPlaceholder activePH = modelService.findPlaceholderFor(getWindow(), activePart); if (activePH != null) { activeParent = activePH.getParent(); } } if (parent == activeParent && part != activePart) { activate(part); return; } MUIElement oldSelectedElement = parent.getSelectedElement(); delegateBringToTop(part); // check to make sure that the currently selected element is actually valid if (oldSelectedElement != currentElement && parent.getChildren().contains(oldSelectedElement) && parent instanceof MGenericStack<?>) { if (oldSelectedElement instanceof MPlaceholder) { oldSelectedElement = ((MPlaceholder) oldSelectedElement).getRef(); } internalFixContext(part, oldSelectedElement); } } }
private static int getIndex(MElementContainer<?> model, String positionInParent) { String id = null; String modifier = null; if (positionInParent != null && positionInParent.length() > 0) { String[] array = positionInParent.split("="); // $NON-NLS-1$ modifier = array[0]; id = array[1]; } if (id == null) { return model.getChildren().size(); } int idx = 0; int size = model.getChildren().size(); while (idx < size) { if (id.equals(model.getChildren().get(idx).getElementId())) { if ("after".equals(modifier)) { // $NON-NLS-1$ idx++; } else if ("endof".equals(modifier)) { // $NON-NLS-1$ // Skip current menu item idx++; // Skip all menu items until next MenuSeparator is found while (idx < size && !(model.getChildren().get(idx) instanceof MToolBarSeparator && model.getChildren().get(idx).getElementId() != null)) { idx++; } } return idx; } idx++; } return id.equals("additions") ? model.getChildren().size() : -1; // $NON-NLS-1$ }
public static void addPartToAppropriateContainer( MPart part, MPartDescriptor descriptor, MApplication application, EModelService service) { // first try and find the container specified by the id in the "parent" persisted state MElementContainer<MUIElement> container = null; String parentId = descriptor.getPersistedState().get(PARENT_ID); if (parentId != null) { @SuppressWarnings("rawtypes") List<MElementContainer> containers = service.findElements(application, parentId, MElementContainer.class, null); if (!containers.isEmpty()) { @SuppressWarnings("unchecked") MElementContainer<MUIElement> uncheckedContainer = containers.get(0); container = uncheckedContainer; } } // next try and find a sibling, and use the sibling's container if (container == null) { List<MPart> siblings = service.findElements(application, descriptor.getElementId(), MPart.class, null); for (MPart sibling : siblings) { if (sibling == part) { continue; } container = sibling.getParent(); if (sibling.isToBeRendered()) { // prefer visible siblings break; } } } if (container != null) { String position = descriptor.getPersistedState().get(POSITION_ID); int index = getPositionIndex(position, container); if (index < 0 || index > container.getChildren().size()) { container.getChildren().add(part); } else { container.getChildren().add(index, part); } } }
public static int indexForId(MElementContainer<MMenuElement> parentMenu, String id) { if (id == null || id.length() == 0) { return -1; } int i = 0; for (MMenuElement item : parentMenu.getChildren()) { if (id.equals(item.getElementId())) { return i; } i++; } return -1; }
private void disconnectReferencedElementsFromPerspectiveWidgets( MElementContainer<? extends MUIElement> container) { for (MUIElement e : container.getChildren()) { if (e instanceof MPlaceholder) { MPlaceholder ph = (MPlaceholder) e; if (ph.isToBeRendered()) { ComponentContainer phComponent = (ComponentContainer) ph.getWidget(); Component refComponent = (Component) ph.getRef().getWidget(); phComponent.removeComponent(refComponent); } } } }
public void handleEvent(Event event) { MUIElement changedElement = (MUIElement) event.getProperty(UIEvents.EventTags.ELEMENT); MElementContainer<?> parent = changedElement.getParent(); // Handle Detached Windows if (parent == null) { parent = (MElementContainer<?>) ((EObject) changedElement).eContainer(); } boolean menuChild = parent instanceof MMenu; // If the parent isn't displayed who cares? if (!(parent instanceof MApplication) && (parent == null || parent.getWidget() == null || menuChild)) return; if (changedElement.isToBeRendered()) { Activator.trace(Policy.DEBUG_RENDERER, "visible -> true", null); // $NON-NLS-1$ // Note that the 'createGui' protocol calls 'childAdded' Object w = createGui(changedElement); if (w instanceof Control && !(w instanceof Shell)) { fixZOrder(changedElement); } } else { Activator.trace(Policy.DEBUG_RENDERER, "visible -> false", null); // $NON-NLS-1$ // Ensure that the element about to be removed is not the // selected element if (parent.getSelectedElement() == changedElement) parent.setSelectedElement(null); // Un-maximize the element before tearing it down if (changedElement.getTags().contains(MAXIMIZED)) changedElement.getTags().remove(MAXIMIZED); // Note that the 'removeGui' protocol calls 'childRemoved' removeGui(changedElement); } }
private void hideElementRecursive(MUIElement element) { if (element == null || element.getWidget() == null) { return; } if (element instanceof MPlaceholder) { MPlaceholder ph = (MPlaceholder) element; element = ph.getRef(); } // Hide any floating windows if (element instanceof MWindow && element.getWidget() != null) { element.setVisible(false); } if (element instanceof MGenericStack<?>) { // For stacks only the currently selected elements are being hidden MGenericStack<?> container = (MGenericStack<?>) element; MUIElement curSel = container.getSelectedElement(); hideElementRecursive(curSel); } else if (element instanceof MElementContainer<?>) { MElementContainer<?> container = (MElementContainer<?>) element; for (MUIElement childElement : container.getChildren()) { hideElementRecursive(childElement); } // OK, now process detached windows if (element instanceof MWindow) { for (MWindow w : ((MWindow) element).getWindows()) { hideElementRecursive(w); } } else if (element instanceof MPerspective) { for (MWindow w : ((MPerspective) element).getWindows()) { hideElementRecursive(w); } } } }
protected void fixZOrder(MUIElement element) { MElementContainer<MUIElement> parent = element.getParent(); if (parent == null) { Object container = ((EObject) element).eContainer(); if (container instanceof MElementContainer<?>) { parent = (MElementContainer<MUIElement>) container; } } if (parent == null || !(element.getWidget() instanceof Control)) return; Control elementCtrl = (Control) element.getWidget(); Control prevCtrl = null; for (MUIElement kid : parent.getChildren()) { if (kid == element) { if (prevCtrl != null) elementCtrl.moveBelow(prevCtrl); else elementCtrl.moveAbove(null); break; } else if (kid.getWidget() instanceof Control) { prevCtrl = (Control) kid.getWidget(); } } Object widget = parent.getWidget(); if (widget instanceof Composite) { Composite composite = (Composite) widget; if (composite.getShell() == elementCtrl.getShell()) { Composite temp = elementCtrl.getParent(); while (temp != composite) { if (temp == null) { return; } temp = temp.getParent(); } composite.layout(true, true); } } }