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); }
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; }
/** * 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); } } } }
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; }
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); } } }
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; }
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); } } }
@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); }
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); }
@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; } } } } } }
/** * @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); } } }
/** * 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 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 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); } }
// 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); } }
/** * @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()); } } }
void removeMenuContributions( final MMenu menuModel, final ArrayList<MMenuElement> menuContributionsToRemove) { for (MMenuElement item : menuContributionsToRemove) { menuModel.getChildren().remove(item); } }