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; }
private MPlaceholder createSharedPart(MPart sharedPart) { // Create and return a reference to the shared part MPlaceholder sharedPartRef = modelService.createModelElement(MPlaceholder.class); sharedPartRef.setElementId(sharedPart.getElementId()); sharedPartRef.setRef(sharedPart); return sharedPartRef; }
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; }
private Object safeCreateGui(MUIElement element) { // Obtain the necessary parent widget Object parent = null; MUIElement parentME = element.getParent(); if (parentME == null) parentME = (MUIElement) ((EObject) element).eContainer(); if (parentME != null) { AbstractPartRenderer renderer = getRendererFor(parentME); if (renderer != null) { if (!element.isVisible()) { parent = getLimboShell(); } else { parent = renderer.getUIContainer(element); } } } // Obtain the necessary parent context IEclipseContext parentContext = null; if (element.getCurSharedRef() != null) { MPlaceholder ph = element.getCurSharedRef(); parentContext = getContext(ph.getParent()); } else if (parentContext == null && element.getParent() != null) { parentContext = getContext(element.getParent()); } else if (parentContext == null && element.getParent() == null) { parentContext = getContext((MUIElement) ((EObject) element).eContainer()); } return safeCreateGui(element, parent, parentContext); }
@Override public MUIElement cloneElement(MUIElement element, MSnippetContainer snippetContainer) { EObject eObj = (EObject) element; MUIElement clone = (MUIElement) EcoreUtil.copy(eObj); // null out all the references List<MPlaceholder> phList = findElements(clone, null, MPlaceholder.class, null); for (MPlaceholder ph : phList) { // Skip placeholders in the sharedArea int location = getElementLocation(ph); if ((location & IN_SHARED_AREA) != 0) { continue; } ph.setRef(null); } if (snippetContainer != null) { MUIElement snippet = findSnippet(snippetContainer, element.getElementId()); if (snippet != null) { snippetContainer.getSnippets().remove(snippet); } snippetContainer.getSnippets().add(clone); } // Cache the original element in the clone's transientData clone.getTransientData().put(CLONED_FROM_KEY, element); return clone; }
@Override public MPlaceholder findPlaceholderFor(MWindow window, MUIElement element) { List<MPlaceholder> phList = findPerspectiveElements(window, null, MPlaceholder.class, null); List<MPlaceholder> elementRefs = new ArrayList<>(); for (MPlaceholder ph : phList) { if (ph.getRef() == element) { elementRefs.add(ph); } } if (elementRefs.size() == 0) { return null; } if (elementRefs.size() == 1) { return elementRefs.get(0); } // If there is more than one placeholder then return the one in the shared area for (MPlaceholder refPh : elementRefs) { int loc = getElementLocation(refPh); if ((loc & IN_SHARED_AREA) != 0) { return refPh; } } // Just return the first one return elementRefs.get(0); }
private void resetPerspectiveModel( MPerspective persp, MWindow window, boolean removeSharedPlaceholders) { if (persp == null) { return; } if (removeSharedPlaceholders) { // Remove any views (Placeholders) from the shared area EPartService ps = window.getContext().get(EPartService.class); List<MArea> areas = findElements(window, null, MArea.class, null); if (areas.size() == 1) { MArea area = areas.get(0); // Strip out the placeholders in visible stacks List<MPlaceholder> phList = findElements(area, null, MPlaceholder.class, null); for (MPlaceholder ph : phList) { ps.hidePart((MPart) ph.getRef()); ph.getParent().getChildren().remove(ph); } // Prevent shared stacks ids from clashing with the ones in the perspective List<MPartStack> stacks = findElements(area, null, MPartStack.class, null); for (MPartStack stack : stacks) { String generatedId = "PartStack@" + Integer.toHexString(stack.hashCode()); // $NON-NLS-1$ stack.setElementId(generatedId); } // Also remove any min/max tags on the area (or its placeholder) MUIElement areaPresentation = area; if (area.getCurSharedRef() != null) { areaPresentation = area.getCurSharedRef(); } areaPresentation.getTags().remove(IPresentationEngine.MAXIMIZED); areaPresentation.getTags().remove(IPresentationEngine.MINIMIZED); areaPresentation.getTags().remove(IPresentationEngine.MINIMIZED_BY_ZOOM); } } // Remove any minimized stacks for this perspective List<MTrimBar> bars = findElements(window, null, MTrimBar.class, null); List<MToolControl> toRemove = new ArrayList<>(); for (MTrimBar bar : bars) { for (MUIElement barKid : bar.getChildren()) { if (!(barKid instanceof MToolControl)) { continue; } String id = barKid.getElementId(); if (id != null && id.contains(persp.getElementId())) { toRemove.add((MToolControl) barKid); } } } for (MToolControl toolControl : toRemove) { // Close any open fast view toolControl.setToBeRendered(false); toolControl.getParent().getChildren().remove(toolControl); } }
// ------------------------------------------------------- // ------------------------------------------------------- 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); } } } }
/** * Returns the parent container of the specified element. If one cannot be found, a check will be * performed to see whether the element is being represented by a placeholder, if it is, the * placeholder's parent will be returned, if any. * * @param element the element to query * @return the element's parent container, or the parent container of the specified element's * current placeholder, if it has one */ private MElementContainer<MUIElement> getParent(MUIElement element) { MElementContainer<MUIElement> parent = element.getParent(); if (parent == null) { MPlaceholder placeholder = element.getCurSharedRef(); if (placeholder == null) { @SuppressWarnings("unchecked") MElementContainer<MUIElement> container = (MElementContainer<MUIElement>) getContainer(); return findContainer(container, element); } return placeholder.getParent(); } return parent; }
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); } } } }
/** * Records the specified parent part's selected element in the activation history if the parent is * a stack. * * @param part the part whose parent's selected element should be checked for activation history * recording */ private void recordStackActivation(MPart part) { MElementContainer<? extends MUIElement> parent = part.getParent(); if (parent instanceof MGenericStack) { recordSelectedActivation(parent); } else if (parent == null) { MPlaceholder placeholder = part.getCurSharedRef(); if (placeholder != null) { parent = placeholder.getParent(); if (parent instanceof MGenericStack) { recordSelectedActivation(parent); } } } }
private void adjustPlaceholder(MPart part) { if (isShared(part)) { MPlaceholder placeholder = part.getCurSharedRef(); // if this part doesn't have any placeholders, we need to make one if (placeholder == null // alternatively, if it has one but it's not in the current container, then we // need to spawn another one as we don't want to reuse the same one and end up // shifting that placeholder to the current container during the add operation || (placeholder.getParent() != null && !isInContainer(placeholder))) { placeholder = createSharedPart(part); part.setCurSharedRef(placeholder); } } }
@Override public Object getUIContainer(MUIElement element) { if (element instanceof MToolBar) { MUIElement container = (MUIElement) ((EObject) element).eContainer(); MUIElement parent = container.getParent(); if (parent == null) { MPlaceholder placeholder = container.getCurSharedRef(); if (placeholder != null) { return placeholder.getParent().getWidget(); } } else { return parent.getWidget(); } } return super.getUIContainer(element); }
@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); } }
private void handleNullRefPlaceHolders(MUIElement element, MWindow refWin, boolean resolve) { // use appContext as MApplication.getContext() is null during the processing of // the model processor classes EPlaceholderResolver resolver = appContext.get(EPlaceholderResolver.class); // Re-resolve any placeholder references List<MPlaceholder> phList = findElements(element, null, MPlaceholder.class, null); List<MPlaceholder> nullRefList = new ArrayList<>(); for (MPlaceholder ph : phList) { if (resolve) { resolver.resolvePlaceholderRef(ph, refWin); } if (ph.getRef() == null) { nullRefList.add(ph); } } for (MPlaceholder ph : nullRefList) { replacePlaceholder(ph); } return; }
@Override public void handleEvent(Event event) { // no need to do anything if we have no listeners if (!listeners.isEmpty()) { Object oldSelected = event.getProperty(UIEvents.EventTags.OLD_VALUE); if (oldSelected instanceof MPlaceholder) { oldSelected = ((MPlaceholder) oldSelected).getRef(); } MPlaceholder placeholder = null; Object selected = event.getProperty(UIEvents.EventTags.NEW_VALUE); if (selected instanceof MPlaceholder) { placeholder = (MPlaceholder) selected; selected = placeholder.getRef(); } MPart oldSelectedPart = oldSelected instanceof MPart ? (MPart) oldSelected : null; MPart selectedPart = selected instanceof MPart ? (MPart) selected : null; if (oldSelectedPart != null && getParts().contains(selectedPart)) { firePartHidden(oldSelectedPart); } if (selectedPart != null && selectedPart.isToBeRendered() && getParts().contains(selectedPart)) { // ask the renderer to create this part if (placeholder == null) { if (selectedPart.getParent().getRenderer() != null) { engine.createGui(selectedPart); firePartVisible(selectedPart); firePartBroughtToTop(selectedPart); } } else if (placeholder.getParent().getRenderer() != null) { engine.createGui(placeholder); firePartVisible(selectedPart); firePartBroughtToTop(selectedPart); } } } }
@Override public void hideLocalPlaceholders(MWindow window, MPerspective perspective) { List<MPlaceholder> globals = findElements(window, null, MPlaceholder.class, null, OUTSIDE_PERSPECTIVE | IN_SHARED_AREA); // Iterate across the perspective(s) removing any 'local' placeholders List<MPerspective> persps = new ArrayList<>(); if (perspective != null) { persps.add(perspective); } else { persps = findElements(window, null, MPerspective.class, null); } for (MPerspective persp : persps) { List<MPlaceholder> locals = findElements(persp, null, MPlaceholder.class, null, IN_ANY_PERSPECTIVE); for (MPlaceholder local : locals) { for (MPlaceholder global : globals) { if (global.getRef() == local.getRef()) { local.setToBeRendered(false); MElementContainer<MUIElement> localParent = local.getParent(); setStackVisibility(localParent); } } } } }
@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); } } }
@Override public boolean isPartOrPlaceholderInPerspective(String elementId, MPerspective perspective) { List<MPart> findElements = modelService.findElements(perspective, elementId, MPart.class, null); if (!findElements.isEmpty()) { MPart part = findElements.get(0); // if that is a shared part, check the placeholders if (workbenchWindow.getSharedElements().contains(part)) { List<MPlaceholder> placeholders = modelService.findElements(perspective, elementId, MPlaceholder.class, null); for (MPlaceholder mPlaceholder : placeholders) { if (mPlaceholder.isVisible() && mPlaceholder.isToBeRendered()) { return true; } } return false; } // not a shared part return part.isVisible() && part.isToBeRendered(); } return false; }
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); } } } }
private void replacePlaceholder(MPlaceholder ph) { MPart part = createModelElement(MPart.class); part.setElementId(ph.getElementId()); part.getTransientData() .put( IPresentationEngine.OVERRIDE_ICON_IMAGE_KEY, ImageDescriptor.getMissingImageDescriptor().createImage()); String label = (String) ph.getTransientData().get(TAG_LABEL); if (label != null) { part.setLabel(label); } else { part.setLabel(getLabel(ph.getElementId())); } part.setContributionURI(COMPATIBILITY_VIEW_URI); part.setCloseable(true); MElementContainer<MUIElement> curParent = ph.getParent(); int curIndex = curParent.getChildren().indexOf(ph); curParent.getChildren().remove(curIndex); curParent.getChildren().add(curIndex, part); if (curParent.getSelectedElement() == ph) { curParent.setSelectedElement(part); } }
public Object createWidget(final MUIElement element, Object parent) { MPlaceholder ph = (MPlaceholder) element; final MUIElement ref = ph.getRef(); ref.setCurSharedRef(ph); List<MPlaceholder> renderedRefs = renderedMap.get(ref); if (renderedRefs == null) { renderedRefs = new ArrayList<MPlaceholder>(); renderedMap.put(ref, renderedRefs); } if (!renderedRefs.contains(ph)) renderedRefs.add(ph); Composite newComp = new Composite((Composite) parent, SWT.NONE); newComp.setLayout(new FillLayout()); Control refWidget = (Control) ref.getWidget(); if (refWidget == null) { ref.setToBeRendered(true); refWidget = (Control) renderingEngine.createGui(ref, newComp, getContextForParent(ref)); } else { if (refWidget.getParent() != newComp) { refWidget.setParent(newComp); } } if (ref instanceof MContext) { IEclipseContext context = ((MContext) ref).getContext(); IEclipseContext newParentContext = getContext(ph); if (context.getParent() != newParentContext) { context.setParent(newParentContext); } } return newComp; }
/* * (non-Javadoc) * * @see * org.eclipse.e4.ui.workbench.renderers.swt.SWTPartRenderer#disposeWidget * (org.eclipse.e4.ui.model.application.ui.MUIElement) */ @Override public void disposeWidget(MUIElement element) { MPlaceholder ph = (MPlaceholder) element; MUIElement refElement = ph.getRef(); Control refCtrl = (Control) refElement.getWidget(); // Remove the element ref from the rendered list List<MPlaceholder> refs = renderedMap.get(refElement); refs.remove(ph); IEclipseContext curContext = modelService.getContainingContext(ph); if (refs.size() == 0) { // Ensure that the image is the 'original' image for this // part. See bug 347471 for details if (refElement instanceof MPart) { MPart thePart = (MPart) refElement; String imageURI = thePart.getIconURI(); thePart.setIconURI(null); thePart.setIconURI(imageURI); } renderingEngine.removeGui(refElement); } else { // Ensure that the dispose of the element reference doesn't cascade // to dispose the 'real' part if (refCtrl != null && !refCtrl.isDisposed()) { MPlaceholder currentRef = refElement.getCurSharedRef(); if (currentRef == ph) { // Find another *rendered* ref to pass the part on to for (MPlaceholder aPH : refs) { Composite phComp = (Composite) aPH.getWidget(); if (phComp == null || phComp.isDisposed()) continue; // Reparent the context(s) (if any) IEclipseContext newParentContext = modelService.getContainingContext(aPH); List<MContext> allContexts = modelService.findElements(refElement, null, MContext.class, null); for (MContext ctxtElement : allContexts) { IEclipseContext theContext = ctxtElement.getContext(); // this may be null if it hasn't been rendered yet if (theContext != null) { if (theContext.getParent() == curContext) { // about to reparent the context, if we're // the active child of the current parent, // deactivate ourselves first if (curContext.getActiveChild() == theContext) { theContext.deactivate(); } theContext.setParent(newParentContext); } } } // reset the 'cur' ref refElement.setCurSharedRef(aPH); // Reparent the widget refCtrl.setParent(phComp); break; } } else if (currentRef != null) { Composite phComp = (Composite) currentRef.getWidget(); if (phComp == null || phComp.isDisposed()) { super.disposeWidget(element); return; } // Reparent the context(s) (if any) IEclipseContext newParentContext = modelService.getContainingContext(currentRef); List<MContext> allContexts = modelService.findElements(refElement, null, MContext.class, null); for (MContext ctxtElement : allContexts) { IEclipseContext theContext = ctxtElement.getContext(); // this may be null if it hasn't been rendered yet if (theContext != null && theContext.getParent() == curContext) { // about to reparent the context, if we're the // active child of the current parent, deactivate // ourselves first if (curContext.getActiveChild() == theContext) { theContext.deactivate(); } theContext.setParent(newParentContext); } } } } } super.disposeWidget(element); }
private void showElementRecursive(MUIElement element) { if (!element.isToBeRendered()) return; if (element instanceof MPlaceholder && element.getWidget() != null) { MPlaceholder ph = (MPlaceholder) element; MUIElement ref = ph.getRef(); ref.setCurSharedRef(ph); ComponentContainer phComponent = (ComponentContainer) ph.getWidget(); Component refComponent = (Component) ph.getRef().getWidget(); phComponent.addComponent(refComponent); element = ref; // top right folder MPartStack topLeftStack = HierarchyUtils.findTopLeftFolder(ph.getRef()); if (topLeftStack != null) { if (ph.getTags().contains(IPresentationEngine.MAXIMIZED)) ((StackWidget) topLeftStack.getWidget()).setState(1); else if (ph.getTags().contains(IPresentationEngine.MINIMIZED)) ((StackWidget) topLeftStack.getWidget()).setState(-1); else ((StackWidget) topLeftStack.getWidget()).setState(0); } } if (element instanceof MContext) { IEclipseContext context = ((MContext) element).getContext(); if (context != null) { IEclipseContext newParentContext = modelService.getContainingContext(element); if (context.getParent() != newParentContext) { context.setParent(newParentContext); } } } // Show any floating windows if (element instanceof MWindow && element.getWidget() != null) { int visCount = 0; for (MUIElement kid : ((MWindow) element).getChildren()) { if (kid.isToBeRendered() && kid.isVisible()) visCount++; } if (visCount > 0) element.setVisible(true); } if (element instanceof MElementContainer<?>) { MElementContainer<?> container = (MElementContainer<?>) element; List<MUIElement> kids = new ArrayList<MUIElement>(container.getChildren()); for (MUIElement childElement : kids) { showElementRecursive(childElement); } // OK, now process detached windows if (element instanceof MWindow) { for (MWindow w : ((MWindow) element).getWindows()) { showElementRecursive(w); } } else if (element instanceof MPerspective) { for (MWindow w : ((MPerspective) element).getWindows()) { showElementRecursive(w); } } } }
private <T> void findElementsRecursive( MApplicationElement searchRoot, Class<T> clazz, Selector matcher, List<T> elements, int searchFlags) { Assert.isLegal(searchRoot != null); if (searchFlags == 0) { return; } // are *we* a match ? boolean classMatch = clazz == null ? true : clazz.isInstance(searchRoot); if (classMatch && matcher.select(searchRoot)) { if (!elements.contains(searchRoot)) { @SuppressWarnings("unchecked") T element = (T) searchRoot; elements.add(element); } } if (searchRoot instanceof MApplication && (searchFlags == ANYWHERE)) { MApplication app = (MApplication) searchRoot; List<MApplicationElement> children = new ArrayList<>(); if (clazz != null) { if (clazz.equals(MHandler.class)) { children.addAll(app.getHandlers()); } else if (clazz.equals(MCommand.class)) { children.addAll(app.getCommands()); } else if (clazz.equals(MBindingContext.class)) { children.addAll(app.getBindingContexts()); } else if (clazz.equals(MBindingTable.class) || clazz.equals(MKeyBinding.class)) { children.addAll(app.getBindingTables()); } // } else { only look for these if specifically asked. // children.addAll(app.getHandlers()); // children.addAll(app.getCommands()); // children.addAll(app.getBindingContexts()); // children.addAll(app.getBindingTables()); } for (MApplicationElement child : children) { findElementsRecursive(child, clazz, matcher, elements, searchFlags); } } if (searchRoot instanceof MBindingContext && (searchFlags == ANYWHERE)) { MBindingContext bindingContext = (MBindingContext) searchRoot; for (MBindingContext child : bindingContext.getChildren()) { findElementsRecursive(child, clazz, matcher, elements, searchFlags); } } if (searchRoot instanceof MBindingTable) { MBindingTable bindingTable = (MBindingTable) searchRoot; for (MKeyBinding child : bindingTable.getBindings()) { findElementsRecursive(child, clazz, matcher, elements, searchFlags); } } // Check regular containers if (searchRoot instanceof MElementContainer<?>) { /* * Bug 455281: If given a window with a primary perspective stack, * and we're not told to look outside of the perspectives (i.e., * searchFlags is missing OUTSIDE_PERSPECTIVE), then just search the * primary perspective stack instead. This ignores special areas * like the compat layer's stack holding the Help, CheatSheets, and * Intro. */ MElementContainer<?> searchContainer = (MElementContainer<?>) searchRoot; MPerspectiveStack primaryStack = null; if (searchRoot instanceof MWindow && (searchFlags & OUTSIDE_PERSPECTIVE) == 0 && (primaryStack = getPrimaryPerspectiveStack((MWindow) searchRoot)) != null) { searchContainer = primaryStack; } if (searchContainer instanceof MPerspectiveStack) { if ((searchFlags & IN_ANY_PERSPECTIVE) != 0) { // Search *all* the perspectives MElementContainer<? extends MUIElement> container = searchContainer; List<? extends MUIElement> children = container.getChildren(); for (MUIElement child : children) { findElementsRecursive(child, clazz, matcher, elements, searchFlags); } } else if ((searchFlags & IN_ACTIVE_PERSPECTIVE) != 0) { // Only search the currently active perspective, if any MPerspective active = ((MPerspectiveStack) searchContainer).getSelectedElement(); if (active != null) { findElementsRecursive(active, clazz, matcher, elements, searchFlags); } } else if ((searchFlags & IN_SHARED_AREA) != 0) { // Only recurse through the shared areas List<MArea> areas = findElements(searchContainer, null, MArea.class, null); for (MArea area : areas) { findElementsRecursive(area, clazz, matcher, elements, searchFlags); } } } else { @SuppressWarnings("unchecked") MElementContainer<MUIElement> container = (MElementContainer<MUIElement>) searchRoot; List<MUIElement> children = container.getChildren(); for (MUIElement child : children) { findElementsRecursive(child, clazz, matcher, elements, searchFlags); } } } // Search Trim if (searchRoot instanceof MTrimmedWindow && (searchFlags & IN_TRIM) != 0) { MTrimmedWindow tw = (MTrimmedWindow) searchRoot; List<MTrimBar> bars = tw.getTrimBars(); for (MTrimBar bar : bars) { findElementsRecursive(bar, clazz, matcher, elements, searchFlags); } } // Search Detached Windows if (searchRoot instanceof MWindow) { MWindow window = (MWindow) searchRoot; for (MWindow dw : window.getWindows()) { findElementsRecursive(dw, clazz, matcher, elements, searchFlags); } MMenu menu = window.getMainMenu(); if (menu != null && (searchFlags & IN_MAIN_MENU) != 0) { findElementsRecursive(menu, clazz, matcher, elements, searchFlags); } // Check for Handlers if (searchFlags == ANYWHERE && MHandler.class.equals(clazz)) { for (MHandler child : window.getHandlers()) { findElementsRecursive(child, clazz, matcher, elements, searchFlags); } } } if (searchRoot instanceof MPerspective) { MPerspective persp = (MPerspective) searchRoot; for (MWindow dw : persp.getWindows()) { findElementsRecursive(dw, clazz, matcher, elements, searchFlags); } } // Search shared elements if (searchRoot instanceof MPlaceholder) { MPlaceholder ph = (MPlaceholder) searchRoot; // Don't search in shared areas unless the flag is set if (ph.getRef() != null && (!(ph.getRef() instanceof MArea) || (searchFlags & IN_SHARED_AREA) != 0)) { findElementsRecursive(ph.getRef(), clazz, matcher, elements, searchFlags); } } if (searchRoot instanceof MPart && (searchFlags & IN_PART) != 0) { MPart part = (MPart) searchRoot; for (MMenu menu : part.getMenus()) { findElementsRecursive(menu, clazz, matcher, elements, searchFlags); } MToolBar toolBar = part.getToolbar(); if (toolBar != null) { findElementsRecursive(toolBar, clazz, matcher, elements, searchFlags); } if (MHandler.class.equals(clazz)) { for (MHandler child : part.getHandlers()) { findElementsRecursive(child, clazz, matcher, elements, searchFlags); } } } }
private void showElementRecursive(MUIElement element) { if (!element.isToBeRendered()) { return; } if (element instanceof MPlaceholder && element.getWidget() != null) { MPlaceholder ph = (MPlaceholder) element; MUIElement ref = ph.getRef(); if (ref.getCurSharedRef() != ph) { ref.setCurSharedRef(ph); WPlaceholderWidget placeholder = (WPlaceholderWidget) ph.getWidget(); @SuppressWarnings("unchecked") WLayoutedWidget<MUIElement> content = (WLayoutedWidget<MUIElement>) ref.getWidget(); placeholder.setContent(content); } element = ref; } if (element instanceof MContext) { IEclipseContext context = ((MContext) element).getContext(); if (context != null) { IEclipseContext newParentContext = modelService.getContainingContext(element); if (context.getParent() != newParentContext) { context.setParent(newParentContext); } } } if (element instanceof MWindow && element.getWidget() != null) { int visCount = 0; for (MUIElement kid : ((MWindow) element).getChildren()) { if (kid.isToBeRendered() && kid.isVisible()) visCount++; } if (visCount > 0) element.setVisible(true); } if (element instanceof MGenericStack) { MGenericStack<?> container = (MGenericStack<?>) element; MUIElement curSel = container.getSelectedElement(); if (curSel == null && container.getChildren().size() > 0) { curSel = container.getChildren().get(0); } if (curSel != null) { showElementRecursive(curSel); } } else if (element instanceof MElementContainer<?>) { MElementContainer<?> container = (MElementContainer<?>) element; for (MUIElement childElement : container.getChildren().toArray(new MUIElement[0])) { showElementRecursive(childElement); } // OK, now process detached windows if (element instanceof MWindow) { for (MWindow w : ((MWindow) element).getWindows()) { showElementRecursive(w); } } else if (element instanceof MPerspective) { for (MWindow w : ((MPerspective) element).getWindows()) { showElementRecursive(w); } } } }