public Object createWidget(final MUIElement element, Object parent) { if (!(element instanceof MMenu)) return null; final MMenu menuModel = (MMenu) element; Menu newMenu = null; if (parent instanceof Decorations) { MUIElement container = (MUIElement) ((EObject) element).eContainer(); if (container instanceof MWindow) { newMenu = new Menu((Decorations) parent, SWT.BAR); newMenu.addDisposeListener( new DisposeListener() { public void widgetDisposed(DisposeEvent e) { cleanUp(menuModel); } }); } else { newMenu = new Menu((Decorations) parent, SWT.POP_UP); } } else if (parent instanceof Menu) { int addIndex = calcVisibleIndex(menuModel); MenuItem newItem = new MenuItem((Menu) parent, SWT.CASCADE, addIndex); setItemText(menuModel, newItem); newItem.setImage(getImage(menuModel)); newItem.setEnabled(menuModel.isEnabled()); return newItem; } else if (parent instanceof Control) { newMenu = new Menu((Control) parent); } return newMenu; }
private void createModelFor(String id) { if (id == null) { id = getClass().getName() + '.' + System.identityHashCode(this); } menuModel = null; for (MMenu item : modelPart.getMenus()) { if (id.equals(item.getElementId()) && item instanceof MPopupMenu && item.getTags().contains(ContributionsAnalyzer.MC_POPUP)) { menuModel = (MPopupMenu) item; break; } } if (menuModel == null) { menuModel = MenuFactoryImpl.eINSTANCE.createPopupMenu(); menuModel.setElementId(id); menuModel.getTags().add(ContributionsAnalyzer.MC_POPUP); modelPart.getMenus().add(menuModel); } IRendererFactory factory = modelPart.getContext().get(IRendererFactory.class); AbstractPartRenderer obj = factory.getRenderer(menuModel, null); if (obj instanceof MenuManagerRenderer) { ((MenuManagerRenderer) obj).linkModelToManager(menuModel, menu); } registerE4Support(); cleanUpContributionCache(); }
public void testCreateMenu() { final MWindow window = createWindowWithOneViewAndMenu(); wb = new E4Workbench(window, appContext); Widget topWidget = (Widget) window.getWidget(); assertTrue(topWidget instanceof Shell); Shell shell = (Shell) topWidget; final Menu menuBar = shell.getMenuBar(); assertNotNull(menuBar); assertEquals(1, menuBar.getItemCount()); final MenuItem fileItem = menuBar.getItem(0); assertEquals("File", fileItem.getText()); final Menu fileMenu = fileItem.getMenu(); fileMenu.notifyListeners(SWT.Show, null); assertEquals(2, fileMenu.getItemCount()); fileMenu.notifyListeners(SWT.Hide, null); MMenu mainMenu = window.getMainMenu(); MMenu modelFileMenu = (MMenu) mainMenu.getChildren().get(0); final MMenuItem item2Model = (MMenuItem) modelFileMenu.getChildren().get(0); item2Model.setToBeRendered(false); fileMenu.notifyListeners(SWT.Show, null); assertEquals(1, fileMenu.getItemCount()); fileMenu.notifyListeners(SWT.Hide, null); item2Model.setToBeRendered(true); fileMenu.notifyListeners(SWT.Show, null); assertEquals(2, fileMenu.getItemCount()); fileMenu.notifyListeners(SWT.Hide, null); }
public static boolean processAddition( final MMenu menuModel, final ArrayList<MMenuElement> menuContributionsToRemove, MMenuContribution menuContribution, final HashSet<String> existingMenuIds, HashSet<String> existingSeparatorNames) { int idx = getIndex(menuModel, menuContribution.getPositionInParent()); if (idx == -1) { return false; } for (MMenuElement item : menuContribution.getChildren()) { if (item instanceof MMenu && existingMenuIds.contains(item.getElementId())) { // skip this, it's already there continue; } else if (item instanceof MMenuSeparator && existingSeparatorNames.contains(item.getElementId())) { // skip this, it's already there continue; } MMenuElement copy = (MMenuElement) EcoreUtil.copy((EObject) item); if (DEBUG) { trace("addMenuContribution " + copy, menuModel.getWidget(), menuModel); // $NON-NLS-1$ } menuContributionsToRemove.add(copy); menuModel.getChildren().add(idx++, copy); if (copy instanceof MMenu && copy.getElementId() != null) { existingMenuIds.add(copy.getElementId()); } else if (copy instanceof MMenuSeparator && copy.getElementId() != null) { existingSeparatorNames.add(copy.getElementId()); } } return true; }
private MHandledMenuItem findMenuItem(final String inItemID, final MMenu inMenu) { inMenu.getChildren(); for (final MMenuElement lItem : inMenu.getChildren()) { if (inItemID.equals(lItem.getElementId())) { return (MHandledMenuItem) lItem; } } return null; }
private MMenu getPopupMenu(final MApplication inApplication, final EModelService inModel) { if (popupStyles == null) { final MPart lPart = (MPart) inModel.find(RelationsConstants.PART_INSPECTOR, inApplication); for (final MMenu lMenu : lPart.getMenus()) { if (RelationsConstants.POPUP_INSPECTOR.equals(lMenu.getElementId())) { popupStyles = lMenu; break; } } } return popupStyles; }
public void handleEvent(Event event) { Object element = event.getProperty(UIEvents.EventTags.ELEMENT); String attName = (String) event.getProperty(UIEvents.EventTags.ATTNAME); if (element instanceof MMenuItem) { MMenuItem itemModel = (MMenuItem) element; if (UIEvents.UIElement.TOBERENDERED.equals(attName)) { Object obj = itemModel.getParent(); if (!(obj instanceof MMenu)) { return; } MenuManager parent = getManager((MMenu) obj); if (itemModel.isToBeRendered()) { if (parent != null) { modelProcessSwitch(parent, itemModel); } } else { IContributionItem ici = getContribution(itemModel); clearModelToContribution(itemModel, ici); if (ici != null && parent != null) { parent.remove(ici); } if (ici != null) { ici.dispose(); } } } } if (UIEvents.UIElement.VISIBLE.equals(attName)) { if (element instanceof MMenu) { MMenu menuModel = (MMenu) element; MenuManager manager = getManager(menuModel); if (manager == null) { return; } manager.setVisible(menuModel.isVisible()); if (manager.getParent() != null) { manager.getParent().markDirty(); } } else if (element instanceof MMenuElement) { MMenuElement itemModel = (MMenuElement) element; Object obj = getContribution(itemModel); if (!(obj instanceof ContributionItem)) { return; } ContributionItem item = (ContributionItem) obj; item.setVisible(itemModel.isVisible()); if (item.getParent() != null) { item.getParent().markDirty(); } } } }
@SuppressWarnings("restriction") @Execute public void execute( MApplication app, EModelService service, IExtensionRegistry registery, IThemeManager mgr) { // sanity check if (menu == null) { return; } List<String> tags = app.getTags(); for (String tag : tags) { if (PROCESSOR_ID.equals(tag)) { return; // already processed } } tags.add(PROCESSOR_ID); IThemeEngine engine = mgr.getEngineForDisplay(Display.getCurrent()); List<ITheme> themes = engine.getThemes(); MCommand switchThemeCommand = ThemeHelper.findCommand(app); // no themes or command, stop processing if (themes.size() <= 0 || switchThemeCommand == null) { return; } themesMenu = service.createModelElement(MMenu.class); themesMenu.setLabel("%switchThemeMenu"); // $NON-NLS-1$ themesMenu.setContributorURI(BUNDLE_ID); for (ITheme theme : themes) { if (!theme.getId().startsWith("org.eclipse.e4.demo.contacts.")) { return; } MParameter parameter = service.createModelElement(MParameter.class); parameter.setName("contacts.commands.switchtheme.themeid"); // $NON-NLS-1$ parameter.setValue(theme.getId()); String iconURI = ThemeHelper.getCSSUri(theme.getId(), registery); if (iconURI != null) { iconURI = iconURI.replace(".css", ".png"); } processTheme(theme.getLabel(), switchThemeCommand, parameter, iconURI, service); } menu.getChildren().add(themesMenu); }
/** * Unlink all contribution items from the given model menu. * * @param renderer the renderer that is holding the links * @param menu the model menu whose children should have its items unlinked from their * corresponding contribution items */ private void unlink(MenuManagerRenderer renderer, MMenu menu) { for (MMenuElement menuElement : menu.getChildren()) { if (menuElement instanceof MOpaqueMenuItem) { MOpaqueMenuItem opaqueMenuItem = (MOpaqueMenuItem) menuElement; Object item = opaqueMenuItem.getOpaqueItem(); if (item instanceof IContributionItem) { renderer.clearModelToContribution(opaqueMenuItem, (IContributionItem) item); opaqueMenuItem.setOpaqueItem(null); } } else if (menuElement instanceof MOpaqueMenuSeparator) { MOpaqueMenuSeparator opaqueMenuItem = (MOpaqueMenuSeparator) menuElement; Object item = opaqueMenuItem.getOpaqueItem(); if (item instanceof IContributionItem) { renderer.clearModelToContribution(opaqueMenuItem, (IContributionItem) item); opaqueMenuItem.setOpaqueItem(null); } } else if (menuElement instanceof MMenu) { MMenu subMenu = (MMenu) menuElement; unlink(renderer, subMenu); MenuManager manager = renderer.getManager(subMenu); if (manager != null) { renderer.clearModelToManager(subMenu, manager); } } else { IContributionItem contribution = renderer.getContribution(menuElement); if (contribution != null) { renderer.clearModelToContribution(menuElement, contribution); } } } }
private void setItemText(MMenu model, MenuItem item) { String text = model.getLocalizedLabel(); if (text == null) { text = ""; // $NON-NLS-1$ } item.setText(text); }
private void showStandaloneViewMenu( ExecutionEvent event, MPart model, MMenu menuModel, Composite partContainer) { Shell shell = partContainer.getShell(); Menu menu = (Menu) menuModel.getWidget(); if (menu == null) { IPresentationEngine engine = (IPresentationEngine) HandlerUtil.getVariable(event, IPresentationEngine.class.getName()); menu = (Menu) engine.createGui(menuModel, shell, model.getContext()); if (menu != null) { final Menu tmpMenu = menu; partContainer.addDisposeListener( new DisposeListener() { public void widgetDisposed(DisposeEvent e) { tmpMenu.dispose(); } }); } } Display display = menu.getDisplay(); Point location = display.map(partContainer, null, partContainer.getLocation()); Point size = partContainer.getSize(); menu.setLocation(location.x + size.x, location.y); menu.setVisible(true); while (!menu.isDisposed() && menu.isVisible()) { if (!display.readAndDispatch()) display.sleep(); } if (!(menu.getData() instanceof MenuManager)) { menu.dispose(); } }
private String getText(MMenu menuModel) { String text = menuModel.getLocalizedLabel(); if (text == null || text.length() == 0) { return NO_LABEL; } return text; }
static boolean isFiltered( MMenu menuModel, MMenuContribution menuContribution, boolean includePopups) { if (includePopups || menuModel.getTags().contains(ContributionsAnalyzer.MC_POPUP)) { return !menuContribution.getTags().contains(ContributionsAnalyzer.MC_POPUP) && menuContribution.getTags().contains(ContributionsAnalyzer.MC_MENU); } if (menuModel.getTags().contains(ContributionsAnalyzer.MC_MENU)) { return !menuContribution.getTags().contains(ContributionsAnalyzer.MC_MENU) && menuContribution.getTags().contains(ContributionsAnalyzer.MC_POPUP); } if (!includePopups) { // not including popups, so filter out popup menu contributions if the menu is a regular // menu return menuContribution.getTags().contains(ContributionsAnalyzer.MC_POPUP); } return false; }
@PostConstruct public void init() { itemMap = new HashMap<>(); MMenu menu = (MMenu) modelService .findElements( application, "at.bestsolution.dart.app.menu.editorfeatures", null, null, EModelService.ANYWHERE | EModelService.IN_MAIN_MENU) .get(0); menu.getChildren().clear(); menu.getChildren() .addAll(Stream.of(Feature.values()).map(this::createFeature).collect(Collectors.toList())); updateFeatureSet(); }
/** * @param menuModel * @param isMenuBar * @param isPopup */ public void processContributions(MMenu menuModel, boolean isMenuBar, boolean isPopup) { if (menuModel.getElementId() == null) { return; } final ArrayList<MMenuContribution> toContribute = new ArrayList<MMenuContribution>(); ContributionsAnalyzer.XXXgatherMenuContributions( menuModel, application.getMenuContributions(), menuModel.getElementId(), toContribute, null, isPopup); generateContributions(menuModel, toContribute, isMenuBar); for (MMenuElement element : menuModel.getChildren()) { if (element instanceof MMenu) { processContributions((MMenu) element, false, isPopup); } } }
private void restorePersistedState(MApplication application, MPart part) { final Map<String, String> persistedState = application.getPersistedState(); showSuppressedLines = toolbox.parseBoolean(persistedState.get(IPersistenceKey.TERMINAL_SUPPRESS_LINES)); showGrblStateLines = toolbox.parseBoolean(persistedState.get(IPersistenceKey.TERMINAL_GRBL_STATE)); showGcodeModeLines = toolbox.parseBoolean(persistedState.get(IPersistenceKey.TERMINAL_GRBL_MODES)); // set the state of the direct menu items according to persisted state // find the two direct menu items final MToolBar toolbar = part.getToolbar(); List<MToolBarElement> toolBarChildren = toolbar.getChildren(); for (MToolBarElement child : toolBarChildren) { if (child instanceof MHandledToolItem && child .getElementId() .equals("de.jungierek.grblrunner.handledtoolitem.terminal.togglesuppresslines")) { LOG.debug( "restorePersistedState: child=" + child.getElementId() + " class=" + child.getClass()); MMenu menu = ((MHandledToolItem) child).getMenu(); if (menu != null) { List<MMenuElement> items = menu.getChildren(); for (MMenuElement item : items) { LOG.debug( "restorePersistedState: item=" + item.getElementId() + "class=" + child.getClass()); switch (item.getElementId()) { case "de.jungierek.grblrunner.directmenuitem.togglesuppresslines.grblstate": ((MMenuItem) item).setSelected(showGrblStateLines); break; case "de.jungierek.grblrunner.directmenuitem.togglesuppresslines.gcodestate": ((MMenuItem) item).setSelected(showGcodeModeLines); break; default: break; } } } } } }
void cleanUp(MMenu menuModel) { ArrayList<ArrayList<MMenuElement>> lists = pendingCleanup.remove(menuModel); if (lists == null) { return; } for (ArrayList<MMenuElement> list : lists) { for (MMenuElement item : list) { menuModel.getChildren().remove(item); } } }
/** * @param parentManager * @param menuModel */ private void processMenu(MenuManager parentManager, MMenu menuModel) { MenuManager menuManager = getManager(menuModel); if (menuManager == null) { String menuText = getText(menuModel); ImageDescriptor desc = getImageDescriptor(menuModel); menuManager = new MenuManager(menuText, desc, menuModel.getElementId()); linkModelToManager(menuModel, menuManager); menuManager.setVisible(menuModel.isVisible()); addToManager(parentManager, menuModel, menuManager); } // processContributions(menuModel, false); List<MMenuElement> parts = menuModel.getChildren(); if (parts != null) { MMenuElement[] plist = parts.toArray(new MMenuElement[parts.size()]); for (int i = 0; i < plist.length; i++) { MMenuElement childME = plist[i]; modelProcessSwitch(menuManager, childME); } } }
private void redirectHandledMenuItems(MMenu menu) { if (menu == null) { return; } for (MMenuElement elmt : menu.getChildren()) { if (elmt instanceof MMenu) { redirectHandledMenuItems((MMenu) elmt); } else if (elmt instanceof MMenuItem) { redirectHandledMenuItem((MMenuItem) elmt); } } }
/* * (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) { if (container.getChildren().size() == 0) { Object obj = container.getWidget(); if (obj instanceof MenuItem) { MenuItem mi = (MenuItem) obj; if (mi.getMenu() == null) { mi.setMenu(new Menu(mi)); } Menu menu = mi.getMenu(); MenuItem menuItem = new MenuItem(menu, SWT.PUSH); menuItem.setText(MenuManagerRendererFilter.NUL_MENU_ITEM); menuItem.setEnabled(false); } } super.processContents(container); Object obj = container.getWidget(); Object menuObj = container; if ((obj instanceof Menu) && (((Menu) obj).getStyle() & SWT.BAR) != 0 && (menuObj instanceof MMenu)) { MMenu menuModel = (MMenu) menuObj; IEclipseContext ctx = getContext(container); ExpressionContext eContext = new ExpressionContext(ctx); ArrayList<MMenuContribution> toContribute = new ArrayList<MMenuContribution>(); ContributionsAnalyzer.gatherMenuContributions( menuModel, application.getMenuContributions(), menuModel.getElementId(), toContribute, eContext, false); addMenuBarContributions(menuModel, toContribute, ctx, eContext); } }
protected void processTheme( String name, MCommand switchCommand, MParameter themeId, String iconURI, EModelService service) { MHandledMenuItem menuItem = service.createModelElement(MHandledMenuItem.class); menuItem.setLabel(name); menuItem.setCommand(switchCommand); menuItem.getParameters().add(themeId); menuItem.setContributorURI(BUNDLE_ID); if (iconURI != null) { menuItem.setIconURI(iconURI); } themesMenu.getChildren().add(menuItem); }
/** * Find the action with the given ID by recursively crawling the provided menu manager. If the * action cannot be found <code>null</code> is returned. * * @param actionId the id to search for * @param menu the menu to search * @return the action or <code>null</code> */ private MMenuItem findAction(String actionId, MMenu menu) { if (menu == null) { return null; } for (MMenuElement item : menu.getChildren()) { if (item instanceof MMenuItem) { MMenuItem mmi = (MMenuItem) item; if (mmi.getElementId() != null && mmi.getElementId().equals(actionId)) return mmi; if (mmi instanceof MHandledMenuItem) { MHandledMenuItem mhmi = (MHandledMenuItem) mmi; if (mhmi.getCommand() != null && actionId.equals(mhmi.getCommand().getElementId())) { return mmi; } } } else if (item instanceof MMenu) { MMenuItem found = findAction(actionId, (MMenu) item); if (found != null) return found; } } return null; }
public static void XXXgatherMenuContributions( final MMenu menuModel, final List<MMenuContribution> menuContributionList, final String id, final ArrayList<MMenuContribution> toContribute, final ExpressionContext eContext, boolean includePopups) { if (id == null || id.length() == 0) { return; } ArrayList<String> popupIds = new ArrayList<String>(); if (includePopups) { popupIds.add(id); for (String tag : menuModel.getTags()) { if (tag.startsWith("popup:")) { // $NON-NLS-1$ String tmp = tag.substring("popup:".length()); // $NON-NLS-1$ if (!popupIds.contains(tmp)) { popupIds.add(tmp); } } } } for (MMenuContribution menuContribution : menuContributionList) { String parentID = menuContribution.getParentId(); if (parentID == null) { // it doesn't make sense for this to be null, temporary workaround for bug 320790 continue; } boolean popupTarget = includePopups && popupIds.contains(parentID); boolean popupAny = includePopups && menuModel instanceof MPopupMenu && POPUP_PARENT_ID.equals(parentID); boolean filtered = isFiltered(menuModel, menuContribution, includePopups); if (filtered || (!popupAny && !popupTarget && !parentID.equals(id)) || !menuContribution.isToBeRendered()) { continue; } toContribute.add(menuContribution); } }
private MWindow createWindowWithOneViewAndMenu() { final MWindow window = createWindowWithOneView(); final MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu(); window.setMainMenu(menuBar); final MMenu fileMenu = MenuFactoryImpl.eINSTANCE.createMenu(); fileMenu.setLabel("File"); fileMenu.setElementId("file"); menuBar.getChildren().add(fileMenu); final MMenuItem item1 = MenuFactoryImpl.eINSTANCE.createDirectMenuItem(); item1.setElementId("item1"); item1.setLabel("item1"); fileMenu.getChildren().add(item1); final MMenuItem item2 = MenuFactoryImpl.eINSTANCE.createDirectMenuItem(); item2.setElementId("item2"); item2.setLabel("item2"); fileMenu.getChildren().add(item2); return window; }
/** * @param menuModel * @param toContribute */ private void generateContributions( MMenu menuModel, ArrayList<MMenuContribution> toContribute, boolean menuBar) { HashSet<String> existingMenuIds = new HashSet<String>(); HashSet<String> existingSeparatorNames = new HashSet<String>(); for (MMenuElement child : menuModel.getChildren()) { String elementId = child.getElementId(); if (child instanceof MMenu && elementId != null) { existingMenuIds.add(elementId); } else if (child instanceof MMenuSeparator && elementId != null) { existingSeparatorNames.add(elementId); } } MenuManager manager = getManager(menuModel); boolean done = toContribute.size() == 0; while (!done) { ArrayList<MMenuContribution> curList = new ArrayList<MMenuContribution>(toContribute); int retryCount = toContribute.size(); toContribute.clear(); for (MMenuContribution menuContribution : curList) { if (!processAddition( menuModel, manager, menuContribution, existingMenuIds, existingSeparatorNames, menuBar)) { toContribute.add(menuContribution); } } // We're done if the retryList is now empty (everything done) or // if the list hasn't changed at all (no hope) done = (toContribute.size() == 0) || (toContribute.size() == retryCount); } }
public static void addMenuContributions( final MMenu menuModel, final ArrayList<MMenuContribution> toContribute, final ArrayList<MMenuElement> menuContributionsToRemove) { HashSet<String> existingMenuIds = new HashSet<String>(); HashSet<String> existingSeparatorNames = new HashSet<String>(); for (MMenuElement child : menuModel.getChildren()) { String elementId = child.getElementId(); if (child instanceof MMenu && elementId != null) { existingMenuIds.add(elementId); } else if (child instanceof MMenuSeparator && elementId != null) { existingSeparatorNames.add(elementId); } } boolean done = toContribute.size() == 0; while (!done) { ArrayList<MMenuContribution> curList = new ArrayList<MMenuContribution>(toContribute); int retryCount = toContribute.size(); toContribute.clear(); for (MMenuContribution menuContribution : curList) { if (!processAddition( menuModel, menuContributionsToRemove, menuContribution, existingMenuIds, existingSeparatorNames)) { toContribute.add(menuContribution); } } // We're done if the retryList is now empty (everything done) or // if the list hasn't changed at all (no hope) done = (toContribute.size() == 0) || (toContribute.size() == retryCount); } }
/** * @param menuManager * @param menuModel */ public void reconcileManagerToModel(MenuManager menuManager, MMenu menuModel) { List<MMenuElement> modelChildren = menuModel.getChildren(); HashSet<MOpaqueMenuItem> oldModelItems = new HashSet<MOpaqueMenuItem>(); HashSet<MOpaqueMenu> oldMenus = new HashSet<MOpaqueMenu>(); HashSet<MOpaqueMenuSeparator> oldSeps = new HashSet<MOpaqueMenuSeparator>(); for (MMenuElement itemModel : modelChildren) { if (itemModel instanceof MOpaqueMenuSeparator) { oldSeps.add((MOpaqueMenuSeparator) itemModel); } else if (itemModel instanceof MOpaqueMenuItem) { oldModelItems.add((MOpaqueMenuItem) itemModel); } else if (itemModel instanceof MOpaqueMenu) { oldMenus.add((MOpaqueMenu) itemModel); } } IContributionItem[] items = menuManager.getItems(); for (int src = 0, dest = 0; src < items.length; src++, dest++) { IContributionItem item = items[src]; if (item instanceof MenuManager) { MenuManager childManager = (MenuManager) item; MMenu childModel = getMenuModel(childManager); if (childModel == null) { MMenu legacyModel = MenuFactoryImpl.eINSTANCE.createOpaqueMenu(); legacyModel.setElementId(childManager.getId()); legacyModel.setVisible(childManager.isVisible()); linkModelToManager(legacyModel, childManager); modelChildren.add(dest, legacyModel); reconcileManagerToModel(childManager, legacyModel); } else { if (childModel instanceof MOpaqueMenu) { oldMenus.remove(childModel); } if (modelChildren.size() > dest) { if (modelChildren.get(dest) != childModel) { modelChildren.remove(childModel); modelChildren.add(dest, childModel); } } else { modelChildren.add(childModel); } } } else if (item.isSeparator() || item.isGroupMarker()) { MMenuElement menuElement = getMenuElement(item); if (menuElement == null) { MOpaqueMenuSeparator legacySep = MenuFactoryImpl.eINSTANCE.createOpaqueMenuSeparator(); legacySep.setElementId(item.getId()); legacySep.setVisible(item.isVisible()); legacySep.setOpaqueItem(item); linkModelToContribution(legacySep, item); modelChildren.add(dest, legacySep); } else if (menuElement instanceof MOpaqueMenuSeparator) { MOpaqueMenuSeparator legacySep = (MOpaqueMenuSeparator) menuElement; oldSeps.remove(legacySep); if (modelChildren.size() > dest) { if (modelChildren.get(dest) != legacySep) { modelChildren.remove(legacySep); modelChildren.add(dest, legacySep); } } else { modelChildren.add(legacySep); } } } else { MMenuElement menuElement = getMenuElement(item); if (menuElement == null) { MOpaqueMenuItem legacyItem = MenuFactoryImpl.eINSTANCE.createOpaqueMenuItem(); legacyItem.setElementId(item.getId()); legacyItem.setVisible(item.isVisible()); legacyItem.setOpaqueItem(item); linkModelToContribution(legacyItem, item); modelChildren.add(dest, legacyItem); } else if (menuElement instanceof MOpaqueMenuItem) { MOpaqueMenuItem legacyItem = (MOpaqueMenuItem) menuElement; oldModelItems.remove(legacyItem); if (modelChildren.size() > dest) { if (modelChildren.get(dest) != legacyItem) { modelChildren.remove(legacyItem); modelChildren.add(dest, legacyItem); } } else { modelChildren.add(legacyItem); } } } } if (!oldModelItems.isEmpty()) { modelChildren.removeAll(oldModelItems); for (MOpaqueMenuItem model : oldModelItems) { clearModelToContribution(model, (IContributionItem) model.getOpaqueItem()); } } if (!oldMenus.isEmpty()) { modelChildren.removeAll(oldMenus); for (MOpaqueMenu oldMenu : oldMenus) { MenuManager oldManager = getManager(oldMenu); clearModelToManager(oldMenu, oldManager); } } if (!oldSeps.isEmpty()) { modelChildren.removeAll(oldSeps); for (MOpaqueMenuSeparator model : oldSeps) { clearModelToContribution(model, (IContributionItem) model.getOpaqueItem()); } } }
// this is similar in nature to: // org.eclipse.e4.ui.internal.workbench.ContributionsAnalyzer.addMenuContributions(MMenu, // ArrayList<MMenuContribution>, ArrayList<MMenuElement>) // the difference is it needs to add all the contributions and manage their // visiblility through a RAT private void addMenuBarContributions( final MMenu menuModel, ArrayList<MMenuContribution> toContribute, final IEclipseContext ctx, final ExpressionContext eContext) { HashSet<String> existingMenuIds = new HashSet<String>(); HashSet<String> existingSeparatorNames = new HashSet<String>(); for (MMenuElement child : menuModel.getChildren()) { String elementId = child.getElementId(); if (child instanceof MMenu && elementId != null) { existingMenuIds.add(elementId); } else if (child instanceof MMenuSeparator && elementId != null) { existingSeparatorNames.add(elementId); } } boolean done = toContribute.size() == 0; while (!done) { ArrayList<MMenuContribution> curList = new ArrayList<MMenuContribution>(toContribute); int retryCount = toContribute.size(); toContribute.clear(); for (final MMenuContribution menuContribution : curList) { final ArrayList<MMenuElement> menuContributionsToRemove = new ArrayList<MMenuElement>(); if (!ContributionsAnalyzer.processAddition( menuModel, menuContributionsToRemove, menuContribution, existingMenuIds, existingSeparatorNames)) { toContribute.add(menuContribution); } else { if (menuContribution.getVisibleWhen() != null) { ctx.runAndTrack( new RunAndTrack() { @Override public boolean changed(IEclipseContext context) { if (!menuModel.isToBeRendered() || !menuModel.isVisible() || menuModel.getWidget() == null) { return false; } boolean rc = ContributionsAnalyzer.isVisible(menuContribution, eContext); for (MMenuElement element : menuContributionsToRemove) { element.setToBeRendered(rc); } return true; } }); } ArrayList<ArrayList<MMenuElement>> lists = pendingCleanup.get(menuModel); if (lists == null) { lists = new ArrayList<ArrayList<MMenuElement>>(); pendingCleanup.put(menuModel, lists); } lists.add(menuContributionsToRemove); } } // We're done if the retryList is now empty (everything done) or // if the list hasn't changed at all (no hope) done = (toContribute.size() == 0) || (toContribute.size() == retryCount); } }
void removeMenuContributions( final MMenu menuModel, final ArrayList<MMenuElement> menuContributionsToRemove) { for (MMenuElement item : menuContributionsToRemove) { menuModel.getChildren().remove(item); } }
/* * (non-Javadoc) * * @see * org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer#createWidget * (org.eclipse.e4.ui.model.application.ui.MUIElement, java.lang.Object) */ @Override public Object createWidget(MUIElement element, Object parent) { if (!(element instanceof MMenu)) return null; final MMenu menuModel = (MMenu) element; Menu newMenu = null; MenuManager menuManager = null; boolean menuBar = false; if (parent instanceof Decorations) { MUIElement container = (MUIElement) ((EObject) element).eContainer(); if (container instanceof MWindow) { menuManager = getManager(menuModel); if (menuManager == null) { menuManager = new MenuManager(NO_LABEL, menuModel.getElementId()); linkModelToManager(menuModel, menuManager); } newMenu = menuManager.createMenuBar((Decorations) parent); ((Decorations) parent).setMenuBar(newMenu); newMenu.setData(menuManager); menuBar = true; } else { menuManager = getManager(menuModel); if (menuManager == null) { menuManager = new MenuManager(NO_LABEL, menuModel.getElementId()); linkModelToManager(menuModel, menuManager); } newMenu = menuManager.createContextMenu((Control) parent); // we can't be sure this is the correct parent. // ((Control) parent).setMenu(newMenu); newMenu.setData(menuManager); } } else if (parent instanceof Menu) { // Object data = ((Menu) parent).getData(); logger.debug( new Exception(), "Trying to render a sub menu " //$NON-NLS-1$ + menuModel + "\n\t" + parent); //$NON-NLS-1$ return null; } else if (parent instanceof Control) { menuManager = getManager(menuModel); if (menuManager == null) { menuManager = new MenuManager(NO_LABEL, menuModel.getElementId()); linkModelToManager(menuModel, menuManager); } newMenu = menuManager.createContextMenu((Control) parent); // we can't be sure this is the correct parent. // ((Control) parent).setMenu(newMenu); newMenu.setData(menuManager); } if (!menuManager.getRemoveAllWhenShown()) { processContributions(menuModel, menuBar, menuModel instanceof MPopupMenu); } if (newMenu != null) { newMenu.addDisposeListener( new DisposeListener() { public void widgetDisposed(DisposeEvent e) { cleanUp(menuModel); } }); } return newMenu; }