// -------------------------------------------------------
// -------------------------------------------------------
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);
}
}
}
}
public void handleEvent(Event event) {
MUIElement changedElement = (MUIElement) event.getProperty(UIEvents.EventTags.ELEMENT);
MUIElement parent = changedElement.getParent();
if (parent == null) {
parent = (MUIElement) ((EObject) changedElement).eContainer();
if (parent == null) {
return;
}
}
AbstractPartRenderer renderer = (AbstractPartRenderer) parent.getRenderer();
if (renderer == null || parent instanceof MToolBar) return;
// Re-parent the control based on the visible state
if (changedElement.isVisible()) {
if (changedElement.isToBeRendered()) {
if (changedElement.getWidget() instanceof Control) {
// Ensure that the control is under its 'real' parent if
// it's visible
Composite realComp = (Composite) renderer.getUIContainer(changedElement);
Control ctrl = (Control) changedElement.getWidget();
ctrl.setParent(realComp);
fixZOrder(changedElement);
}
if (parent instanceof MElementContainer<?>) {
renderer.childRendered((MElementContainer<MUIElement>) parent, changedElement);
}
}
} else {
// Put the control under the 'limbo' shell
if (changedElement.getWidget() instanceof Control) {
Control ctrl = (Control) changedElement.getWidget();
if (!(ctrl instanceof Shell)) {
ctrl.getShell().layout(new Control[] {ctrl}, SWT.DEFER);
}
ctrl.setParent(getLimboShell());
}
if (parent instanceof MElementContainer<?>) {
renderer.hideChild((MElementContainer<MUIElement>) parent, changedElement);
}
}
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer#hideChild
* (org.eclipse.e4.ui.model.application.MElementContainer,
* org.eclipse.e4.ui.model.application.MUIElement)
*/
@Override
public void hideChild(MElementContainer<MUIElement> parentElement, MUIElement child) {
super.hideChild(parentElement, child);
// Since there's no place to 'store' a child that's not in a menu
// we'll blow it away and re-create on an add
Widget widget = (Widget) child.getWidget();
if (widget != null && !widget.isDisposed()) widget.dispose();
}
@Override
public void dragEnter(MUIElement dragElement, DnDInfo info) {
super.dragEnter(dragElement, info);
clientBounds = dropCTF.getClientArea();
clientBounds = Display.getCurrent().map(dropCTF, null, clientBounds);
ctfBounds = dropCTF.getBounds();
ctfBounds = Display.getCurrent().map(dropCTF.getParent(), null, ctfBounds);
// Find the root of the dropStack's sash structure
outerRelTo = dropStack.getParent();
if (outerRelTo instanceof MPartSashContainer) {
while (outerRelTo != null && !(outerRelTo.getWidget() instanceof Composite))
outerRelTo = outerRelTo.getParent();
}
// If the stack is in an MArea or a Perspective then allow 'outer' docking
if (outerRelTo instanceof MArea) {
// If the relTo is in the MArea then use its 'curSharedRef'
outerRelTo = outerRelTo.getCurSharedRef();
} else if (outerRelTo instanceof MPartSashContainer) {
MUIElement relToParent = outerRelTo.getParent();
if (relToParent instanceof MArea) {
outerRelTo = relToParent.getCurSharedRef();
} else if (relToParent instanceof MPerspective) {
outerRelTo = relToParent.getParent(); // PerspectiveStack
} else {
outerRelTo = null;
}
} else {
outerRelTo = null;
}
if (outerRelTo != null) {
Composite outerComposite = (Composite) outerRelTo.getWidget();
ocBounds = outerComposite.getBounds();
ocBounds = Display.getCurrent().map(outerComposite.getParent(), null, ocBounds);
} else {
ocBounds = null;
}
getDockLocation(info);
showFeedback(curDockLocation);
}
private void disposeToolbarIfNecessary(MUIElement element) {
Composite composite = (Composite) element.getWidget();
ToolBar toolbar = findToolbar(composite);
if (toolbar != null && hasOnlySeparators(toolbar)) {
toolbar.dispose();
if (composite.getChildren().length > 0) {
composite.getChildren()[0].dispose();
}
}
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.e4.ui.workbench.renderers.swt.PartFactory#hookControllerLogic
* (org.eclipse.e4.ui.model.application.MPart)
*/
@Override
public void hookControllerLogic(final MUIElement me) {
super.hookControllerLogic(me);
if (!(me instanceof MPart)) {
return;
}
Widget widget = (Widget) me.getWidget();
if (widget instanceof Composite) {
widget.addListener(SWT.Activate, activationListener);
}
}
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);
}
}
}
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);
}
}
}
}
@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 void hideChild(MElementContainer<MUIElement> parentElement, MUIElement child) {
super.hideChild(parentElement, child);
// Since there's no place to 'store' a child that's not in a menu
// we'll blow it away and re-create on an add
Widget widget = (Widget) child.getWidget();
if (widget != null && !widget.isDisposed()) {
widget.dispose();
}
ToolBar toolbar = (ToolBar) getUIContainer(child);
if (toolbar != null && !toolbar.isDisposed()) {
toolbar.getShell().layout(new Control[] {toolbar}, SWT.DEFER);
}
disposeToolbarIfNecessary(parentElement);
}
@Override
public boolean canDrop(MUIElement dragElement, DnDInfo info) {
if (!(dragElement instanceof MStackElement) && !(dragElement instanceof MPartStack))
return false;
dropStack = null;
// Hack! allow splitting the 'empty' editor area stack
if (info.curElement instanceof MPartStack) {
MPartStack stack = (MPartStack) info.curElement;
if (dndManager.getModelService().isLastEditorStack(stack)) dropStack = stack;
}
if (dropStack == null) {
if (!(info.curElement instanceof MStackElement)
&& !dndManager.getModelService().isLastEditorStack(info.curElement)) return false;
// Detect placeholders
MUIElement parent = info.curElement.getParent();
if (info.curElement instanceof MPart && info.curElement.getCurSharedRef() != null)
parent = info.curElement.getCurSharedRef().getParent();
if (!(parent instanceof MPartStack) || !(parent.getWidget() instanceof CTabFolder))
return false;
dropStack = (MPartStack) parent;
}
// You can only drag MParts from window to window
if (!(dragElement instanceof MPart)) {
EModelService ms = dndManager.getModelService();
MWindow dragElementWin = ms.getTopLevelWindowFor(dragElement);
MWindow dropWin = ms.getTopLevelWindowFor(dropStack);
if (dragElementWin != dropWin) return false;
}
// We can't split ourselves with if the element being dragged is the only element in the
// stack (we check for '2' because the dragAgent puts a Drag Placeholder in the stack)
MUIElement dragParent = dragElement.getParent();
if (dragParent == dropStack && dropStack.getChildren().size() == 2) return false;
dropCTF = (CTabFolder) dropStack.getWidget();
return true;
}
@Override
public void handleEvent(Event event) {
final MUIElement changedElement = (MUIElement) event.getProperty(EventTags.ELEMENT);
if (!changedElement.getTags().contains(HOSTED_ELEMENT)) {
return;
}
if (changedElement.getWidget() != null) {
return;
}
EObject eObj = (EObject) changedElement;
if (!(eObj.eContainer() instanceof MWindow)) {
return;
}
MWindow hostingWindow = (MWindow) eObj.eContainer();
hostingWindow.getSharedElements().remove(changedElement);
changedElement.getTags().remove(HOSTED_ELEMENT);
}
@Override
public void hideChild(MElementContainer<MUIElement> parentElement, MUIElement child) {
super.hideChild(parentElement, child);
// only handle the disposal of this element if it was actually rendered
// by the engine
if (child.getRenderer() != null) {
// Since there's no place to 'store' a child that's not in a menu
// we'll blow it away and re-create on an add
Widget widget = (Widget) child.getWidget();
if (widget != null && !widget.isDisposed()) {
widget.dispose();
}
ToolBar toolbar = (ToolBar) getUIContainer(child);
if (toolbar != null && !toolbar.isDisposed()) {
toolbar.pack(true);
toolbar.getShell().layout(new Control[] {toolbar}, SWT.DEFER);
}
// disposeToolbarIfNecessary(parentElement);
}
}
private void createElement(MUIElement element) {
if (modelService.isHostedElement(element, workbenchWindow)) {
// assume the client has full control
return;
}
MPlaceholder placeholder = element.getCurSharedRef();
if (placeholder != null) {
element.setToBeRendered(true);
element = placeholder;
}
// render this element
element.setToBeRendered(true);
// render all of its parents
MUIElement parentWindow = workbenchWindow;
// determine the top parent that needs to be forcibly created
MUIElement target = null;
MElementContainer<MUIElement> parent = element.getParent();
while (parent != null && parent != parentWindow) {
parent.setToBeRendered(true);
if (parent.getWidget() == null) {
target = parent;
}
parent = parent.getParent();
}
if (target != null) {
// force the element's parent hierarchy to be created
engine.createGui(target);
}
// ask the engine to create the element
if (element.getWidget() == null) engine.createGui(element);
parent = element.getParent();
if (parent != null && parent.getChildren().size() == 1) {
// if we're the only child, set ourselves as the selected element
parent.setSelectedElement(element);
}
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.e4.ui.workbench.renderers.swt.SWTPartRenderer#hookControllerLogic
* (org.eclipse.e4.ui.model.application.MUIElement)
*/
@Override
public void hookControllerLogic(MUIElement me) {
// If the item is a CHECK or RADIO update the model's state to match
super.hookControllerLogic(me);
// 'Execute' the operation if possible
if (me instanceof MHandledItem) {
final MHandledItem item = (MHandledItem) me;
final IEclipseContext lclContext = getContext(me);
MenuItem mi = (MenuItem) me.getWidget();
mi.addListener(
SWT.Selection,
new Listener() {
public void handleEvent(Event e) {
EHandlerService service =
(EHandlerService) lclContext.get(EHandlerService.class.getName());
ParameterizedCommand cmd = item.getWbCommand();
if (cmd == null) {
return;
}
final IEclipseContext staticContext =
EclipseContextFactory.create(HMI_STATIC_CONTEXT);
if (e != null) {
staticContext.set(Event.class, e);
}
ContributionsAnalyzer.populateModelInterfaces(
item, staticContext, item.getClass().getInterfaces());
try {
service.executeHandler(cmd, staticContext);
} finally {
staticContext.dispose();
}
}
});
}
}
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;
}
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);
}
}
}
}
/*
* (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);
}
}
}
}
public void handleEvent(Event event) {
Object changedObj = event.getProperty(UIEvents.EventTags.ELEMENT);
if (!(changedObj instanceof MElementContainer<?>)) return;
MElementContainer<MUIElement> changedElement = (MElementContainer<MUIElement>) changedObj;
boolean isApplication = changedObj instanceof MApplication;
boolean menuChild = changedObj instanceof MMenu;
// If the parent isn't in the UI then who cares?
AbstractPartRenderer renderer = getRendererFor(changedElement);
if ((!isApplication && renderer == null) || menuChild) return;
String eventType = (String) event.getProperty(UIEvents.EventTags.TYPE);
if (UIEvents.EventTypes.ADD.equals(eventType)) {
Activator.trace(Policy.DEBUG_RENDERER, "Child Added", null); // $NON-NLS-1$
MUIElement added = (MUIElement) event.getProperty(UIEvents.EventTags.NEW_VALUE);
// OK, we have a new -visible- part we either have to create
// it or host it under the correct parent. Note that we
// explicitly do *not* render non-selected elements in
// stacks (to support lazy loading).
boolean isStack = changedObj instanceof MGenericStack<?>;
boolean hasWidget = added.getWidget() != null;
boolean isSelected = added == changedElement.getSelectedElement();
boolean renderIt = !isStack || hasWidget || isSelected;
if (renderIt) {
// NOTE: createGui will call 'childAdded' if successful
Object w = createGui(added);
if (w instanceof Control && !(w instanceof Shell)) {
final Control ctrl = (Control) w;
fixZOrder(added);
if (!ctrl.isDisposed()) {
ctrl.getShell().layout(new Control[] {ctrl}, SWT.DEFER);
}
}
} else {
if (renderer != null && added.isToBeRendered())
renderer.childRendered(changedElement, added);
}
// If the element being added is a placeholder, check to see if
// it's 'globally visible' and, if so, remove all other
// 'local' placeholders referencing the same element.
int newLocation = modelService.getElementLocation(added);
if (newLocation == EModelService.IN_SHARED_AREA
|| newLocation == EModelService.OUTSIDE_PERSPECTIVE) {
MWindow topWin = modelService.getTopLevelWindowFor(added);
modelService.hideLocalPlaceholders(topWin, null);
}
} else if (UIEvents.EventTypes.REMOVE.equals(eventType)) {
Activator.trace(Policy.DEBUG_RENDERER, "Child Removed", null); // $NON-NLS-1$
MUIElement removed = (MUIElement) event.getProperty(UIEvents.EventTags.OLD_VALUE);
// Removing invisible elements is a NO-OP as far as the
// renderer is concerned
if (!removed.isToBeRendered()) return;
if (removed.getWidget() instanceof Control) {
Control ctrl = (Control) removed.getWidget();
ctrl.setLayoutData(null);
ctrl.getParent().layout(new Control[] {ctrl}, SWT.CHANGED | SWT.DEFER);
}
// Ensure that the element about to be removed is not the
// selected element
if (changedElement.getSelectedElement() == removed)
changedElement.setSelectedElement(null);
if (renderer != null) renderer.hideChild(changedElement, removed);
}
}
public Object safeCreateGui(
MUIElement element, Object parentWidget, IEclipseContext parentContext) {
if (!element.isToBeRendered()) return null;
if (!renderedElements.contains(element)) renderedElements.add(element);
// no creates while processing a remove
if (removeRoot != null) {
return null;
}
Object currentWidget = element.getWidget();
if (currentWidget != null) {
if (currentWidget instanceof Control) {
Control control = (Control) currentWidget;
// make sure the control is visible
control.setVisible(true);
if (parentWidget instanceof Composite) {
Composite currentParent = control.getParent();
if (currentParent != parentWidget) {
// check if the original parent was a tab folder
if (currentParent instanceof CTabFolder) {
CTabFolder folder = (CTabFolder) currentParent;
// if we used to be the tab folder's top right
// control, unset it
if (folder.getTopRight() == control) {
folder.setTopRight(null);
}
}
// the parents are different so we should reparent it
control.setParent((Composite) parentWidget);
}
}
}
// Reparent the context (or the kid's context)
if (element instanceof MContext) {
IEclipseContext ctxt = ((MContext) element).getContext();
if (ctxt != null) ctxt.setParent(parentContext);
} else {
List<MContext> childContexts =
modelService.findElements(element, null, MContext.class, null);
for (MContext c : childContexts) {
// Ensure that we only reset the context of our direct
// children
MUIElement kid = (MUIElement) c;
MUIElement parent = kid.getParent();
if (parent == null && kid.getCurSharedRef() != null)
parent = kid.getCurSharedRef().getParent();
if (!(element instanceof MPlaceholder) && parent != element) continue;
if (c.getContext() != null && c.getContext().getParent() != parentContext) {
c.getContext().setParent(parentContext);
}
}
}
// Now that we have a widget let the parent (if any) know
if (element.getParent() instanceof MUIElement) {
MElementContainer<MUIElement> parentElement = element.getParent();
AbstractPartRenderer parentRenderer = getRendererFor(parentElement);
if (parentRenderer != null) parentRenderer.childRendered(parentElement, element);
}
return element.getWidget();
}
if (element instanceof MContext) {
MContext ctxt = (MContext) element;
// Assert.isTrue(ctxt.getContext() == null,
// "Before rendering Context should be null");
if (ctxt.getContext() == null) {
IEclipseContext lclContext = parentContext.createChild(getContextName(element));
populateModelInterfaces(ctxt, lclContext, element.getClass().getInterfaces());
ctxt.setContext(lclContext);
// System.out.println("New Context: " + lclContext.toString()
// + " parent: " + parentContext.toString());
// make sure the context knows about these variables that have
// been defined in the model
for (String variable : ctxt.getVariables()) {
lclContext.declareModifiable(variable);
}
Map<String, String> props = ctxt.getProperties();
for (String key : props.keySet()) {
lclContext.set(key, props.get(key));
}
E4Workbench.processHierarchy(element);
}
}
// Create a control appropriate to the part
Object newWidget = createWidget(element, parentWidget);
// Remember that we've created the control
if (newWidget != null) {
AbstractPartRenderer renderer = getRendererFor(element);
// Have the renderer hook up any widget specific listeners
renderer.hookControllerLogic(element);
// Process its internal structure through the renderer that created
// it
if (element instanceof MElementContainer) {
renderer.processContents((MElementContainer<MUIElement>) element);
}
// Allow a final chance to set up
renderer.postProcess(element);
// Now that we have a widget let the parent (if any) know
if (element.getParent() instanceof MUIElement) {
MElementContainer<MUIElement> parentElement = element.getParent();
AbstractPartRenderer parentRenderer = getRendererFor(parentElement);
if (parentRenderer != null) parentRenderer.childRendered(parentElement, element);
}
} else {
// failed to create the widget, dispose its context if necessary
if (element instanceof MContext) {
MContext ctxt = (MContext) element;
IEclipseContext lclContext = ctxt.getContext();
if (lclContext != null) {
lclContext.dispose();
ctxt.setContext(null);
}
}
}
return newWidget;
}