com.vaadin.ui.MenuBar

Here are the examples of the java api com.vaadin.ui.MenuBar taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

5 Examples 7

18 Source : AbstractDashboardMenu.java
with Apache License 2.0
from ijazfx

/**
 * A responsive menu component providing user information and the controls for
 * primary navigation between the views.
 */
public abstract clreplaced AbstractDashboardMenu extends CustomComponent {

    private static final long serialVersionUID = 1L;

    public static final String ID = "dashboard-menu";

    public static final String REPORTS_BADGE_ID = "dashboard-menu-reports-badge";

    public static final String NOTIFICATIONS_BADGE_ID = "dashboard-menu-notifications-badge";

    private static final String STYLE_VISIBLE = "valo-menu-visible";

    private static final String STYLE_SELECTED = "selected";

    private MenuItem userMenuItem;

    private volatile boolean shouldBuild = true;

    public AbstractDashboardMenu() {
        if (!isSpringComponent()) {
            postConstruct();
        }
    }

    public AbstractDashboardMenu(List<Component> menuItems) {
        if (!isSpringComponent()) {
            postConstruct();
        }
    }

    protected boolean isSpringComponent() {
        return this.getClreplaced().getAnnotation(SpringComponent.clreplaced) != null;
    }

    @PostConstruct
    private void postConstruct() {
        postInitialize();
    }

    public AbstractDashboardMenu build() {
        if (shouldBuild) {
            synchronized (this) {
                if (shouldBuild) {
                    setId(ID);
                    setPrimaryStyleName("valo-menu");
                    setSizeUndefined();
                    DashboardEventBus.sessionInstance().register(this);
                    setCompositionRoot(buildContent());
                    postBuild();
                    shouldBuild = false;
                }
            }
        }
        return this;
    }

    protected void postBuild() {
    }

    private Component buildContent() {
        final CssLayout menuContent = new CssLayout();
        menuContent.addStyleName("sidebar");
        menuContent.addStyleName(ValoTheme.MENU_PART);
        menuContent.addStyleName("no-vertical-drag-hints");
        menuContent.addStyleName("no-horizontal-drag-hints");
        menuContent.setWidth(null);
        menuContent.setHeight("100%");
        menuContent.addComponent(buildreplacedle());
        menuContent.addComponent(buildUserMenu());
        menuContent.addComponent(buildToggleButton());
        menuContent.addComponent(buildMenuItems());
        return menuContent;
    }

    private Component buildreplacedle() {
        MVerticalLayout layout = new MVerticalLayout();
        Image logo = dashboardSetup().dashboardLogo();
        if (logo != null) {
            layout.setStyleName("valo-menu-replacedle-with-image");
            logo.setHeight("80px");
            layout.addComponent(logo);
        }
        Component replacedle = new Label(dashboardSetup().dashboardreplacedle(), ContentMode.HTML);
        MHorizontalLayout replacedleWrapper = new MHorizontalLayout(replacedle);
        replacedleWrapper.setComponentAlignment(replacedle, Alignment.MIDDLE_CENTER);
        replacedleWrapper.addStyleName("valo-menu-replacedle");
        layout.addComponents(replacedleWrapper);
        return layout;
    }

    protected abstract AbstractDashboardSetup dashboardSetup();

    private GxAuthenticatedUser getCurrentUser() {
        return (GxAuthenticatedUser) VaadinSession.getCurrent().getAttribute(GxAuthenticatedUser.clreplaced.getName());
    }

    private Component buildUserMenu() {
        if (userMenu == null) {
            userMenu = new MenuBar();
        }
        userMenu.removeItems();
        userMenu.addStyleName("user-menu");
        final GxAuthenticatedUser user = getCurrentUser();
        if (user != null) {
            byte[] photoBytes = user.getProfilePhoto();
            Resource photo = null;
            if (photoBytes != null) {
                photo = new StreamResource(new StreamResource.StreamSource() {

                    @Override
                    public InputStream getStream() {
                        ByteArrayInputStream bais = new ByteArrayInputStream(photoBytes);
                        return bais;
                    }
                }, user.getUsername() + "_photo");
            } else {
                if (user.getGender() == GenderEnum.Female) {
                    photo = dashboardSetup().femaleAvatar();
                } else {
                    photo = dashboardSetup().maleAvatar();
                }
            }
            boolean shouldAddSeparator = false;
            userMenuItem = userMenu.addItem("", photo, null);
            userMenuItem.setText(user.getFirstNameLastName());
            if (dashboardSetup().profileComponent() != null) {
                shouldAddSeparator = true;
                userMenuItem.addItem("Profile", new Command() {

                    @Override
                    public void menuSelected(final MenuItem selectedItem) {
                        BaseProfileForm profileForm = dashboardSetup().profileComponent();
                        GxAuthenticatedUser user = DashboardUtils.getLoggedInUser();
                        profileForm.setEnreplacedy(GxAuthenticatedUser.clreplaced, user);
                        profileForm.openInModalPopup();
                    }
                });
            }
            userMenuItem.addItem("Change Preplacedword", new Command() {

                @Override
                public void menuSelected(final MenuItem selectedItem) {
                    Page.getCurrent().setLocation("/reset-preplacedword");
                }
            });
            if (shouldAddSeparator) {
                userMenuItem.addSeparator();
            }
            if (userMenuItems() != null && !userMenuItems().isEmpty()) {
                for (TRMenuItem menuItem : userMenuItems()) {
                    userMenuItem.addItem(menuItem.caption(), menuItem.icon(), menuItem.command());
                }
            }
            if (user != null) {
                userMenuItem.addItem("Sign Out", new Command() {

                    @Override
                    public void menuSelected(final MenuItem selectedItem) {
                        VaadinSession.getCurrent().setAttribute(GxAuthenticatedUser.clreplaced, null);
                        Page.getCurrent().reload();
                    }
                });
            }
        }
        return userMenu;
    }

    private Component buildToggleButton() {
        Button valoMenuToggleButton = new Button("Menu", new TRButtonClickListener() {

            @Override
            public void onButtonClick(ClickEvent event) {
                if (getCompositionRoot().getStyleName().contains(STYLE_VISIBLE)) {
                    getCompositionRoot().removeStyleName(STYLE_VISIBLE);
                } else {
                    getCompositionRoot().addStyleName(STYLE_VISIBLE);
                }
            }
        });
        valoMenuToggleButton.setIcon(FontAwesome.LIST);
        valoMenuToggleButton.addStyleName("valo-menu-toggle");
        valoMenuToggleButton.addStyleName(ValoTheme.BUTTON_BORDERLESS);
        valoMenuToggleButton.addStyleName(ValoTheme.BUTTON_SMALL);
        return valoMenuToggleButton;
    }

    private Component buildMenuItems() {
        CssLayout menuItemsLayout = new CssLayout();
        menuItemsLayout.addStyleName("valo-menuitems");
        Collection<TRMenuItem> items = menuItems();
        backButton = new ValoMenuItemButton("Back", GrapheneeTheme.BACK_ICON);
        backButton.setVisible(false);
        backButton.withListener(new TRButtonClickListener() {

            @Override
            public void onButtonClick(ClickEvent event) {
                String viewName = null;
                focusedMenuItem = focusedMenuItem.getParent() != null ? focusedMenuItem.getParent().getParent() : null;
                if (focusedMenuItem == null) {
                    buttonsMap.keySet().forEach(mi -> {
                        buttonsMap.get(mi).setVisible(mi.getParent() == null);
                    });
                    backButton.setVisible(false);
                    viewName = menuItems().get(0).viewName();
                } else {
                    buttonsMap.values().forEach(vmib -> vmib.setVisible(false));
                    focusedMenuItem.getChildren().forEach(mi -> {
                        buttonsMap.get(mi).setVisible(true);
                    });
                    backButton.setVisible(true);
                    viewName = focusedMenuItem.getChildren().iterator().next().viewName();
                }
                // if (viewName == null)
                // viewName = dashboardSetup().dashboardViewName();
                if (viewName != null)
                    UI.getCurrent().getNavigator().navigateTo(viewName);
            }
        });
        generateValoMenuItemButtons(menuItemsLayout, items);
        menuItemsLayout.addComponent(backButton, 0);
        buttonsMap.keySet().forEach(mi -> {
            buttonsMap.get(mi).setVisible(mi.getParent() == null);
        });
        return menuItemsLayout;
    }

    HashMap<TRMenuItem, ValoMenuItemButton> buttonsMap = new HashMap<>();

    private ValoMenuItemButton backButton;

    private MenuBar userMenu;

    private TRMenuItem focusedMenuItem = null;

    private void generateValoMenuItemButtons(CssLayout menuItemsLayout, Collection<TRMenuItem> items) {
        if (items != null && !items.isEmpty()) {
            for (TRMenuItem menuItem : items) {
                if (buttonsMap.containsKey(menuItem))
                    continue;
                ValoMenuItemButton valoMenuItemButton = new ValoMenuItemButton(menuItem.hasChildren() ? null : menuItem.viewName(), menuItem.caption(), menuItem.icon()).withListener(event -> {
                    focusedMenuItem = menuItem;
                    if (menuItem.viewName() != null)
                        UI.getCurrent().getNavigator().navigateTo(menuItem.viewName());
                    if (menuItem.hasChildren()) {
                        buttonsMap.values().forEach(vmib -> vmib.setVisible(false));
                        menuItem.getChildren().forEach(mi -> {
                            buttonsMap.get(mi).setVisible(true);
                        });
                        backButton.setVisible(true);
                    }
                });
                valoMenuItemButton.setBadgeId(menuItem.badgeId());
                valoMenuItemButton.setBadge(menuItem.badge());
                menuItemsLayout.addComponent(valoMenuItemButton);
                buttonsMap.put(menuItem, valoMenuItemButton);
                if (menuItem.hasChildren()) {
                    generateValoMenuItemButtons(menuItemsLayout, menuItem.getChildren());
                }
            }
        }
    }

    protected List<TRMenuItem> menuItems() {
        return dashboardSetup().menuItems();
    }

    protected List<TRMenuItem> userMenuItems() {
        return dashboardSetup().profileMenuItems();
    }

    protected void postInitialize() {
    }

    public static clreplaced ValoMenuItemButton extends CssLayout {

        private static final long serialVersionUID = 1L;

        private final String viewName;

        private Button button;

        private String badgeId;

        private Label badge;

        public ValoMenuItemButton(String replacedle, Resource icon) {
            this(null, replacedle, icon, null);
        }

        public ValoMenuItemButton(String replacedle, Resource icon, ClickListener listener) {
            this(null, replacedle, icon);
            if (listener != null) {
                button.addClickListener(listener);
            }
        }

        public ValoMenuItemButton(String viewName, String replacedle, Resource icon) {
            this(viewName, replacedle, icon, null);
        }

        public ValoMenuItemButton(String viewName, String replacedle, Resource icon, ClickListener listener) {
            setWidth("100%");
            setPrimaryStyleName("valo-menu-item");
            setStyleName("badgewrapper");
            this.viewName = viewName;
            this.badgeId = null;
            button = new Button();
            button.setCaption(replacedle);
            button.setIcon(icon);
            button.setPrimaryStyleName("valo-menu-item");
            badge = new Label();
            badge.setVisible(false);
            badge.setWidthUndefined();
            badge.setPrimaryStyleName(ValoTheme.MENU_BADGE);
            withListener(listener);
            addComponents(button, badge);
        }

        public void setBadgeId(String badgeId) {
            this.badgeId = badgeId;
        }

        public void setBadge(String value) {
            badge.setValue(value);
            badge.setVisible(!Strings.isNullOrEmpty(value));
        }

        public ValoMenuItemButton withListener(ClickListener listener) {
            if (listener != null) {
                button.addClickListener(listener);
            }
            return this;
        }

        @Override
        public void setVisible(boolean visible) {
            super.setVisible(visible);
            if (visible) {
                addStyleName("show");
                removeStyleName("hide");
            } else {
                removeStyleName("show");
                addStyleName("hide");
            }
        }
    }

    @Subscribe
    public void postViewChange(final PostViewChangeEvent event) {
        // After a successful view change the menu can be hidden in mobile view.
        getCompositionRoot().removeStyleName(STYLE_VISIBLE);
        buttonsMap.values().forEach(vmib -> vmib.removeStyleName(STYLE_SELECTED));
        for (TRMenuItem mi : buttonsMap.keySet()) {
            ValoMenuItemButton vmib = buttonsMap.get(mi);
            if (!Strings.isNullOrEmpty(vmib.viewName)) {
                if (vmib.viewName.equals(event.getViewName() + "/" + event.getParameters()) || (vmib.viewName.equals(event.getViewName()) && event.getParameters().equalsIgnoreCase(""))) {
                    vmib.addStyleName(STYLE_SELECTED);
                    focusedMenuItem = mi;
                }
            }
        }
        if (focusedMenuItem != null) {
            if (focusedMenuItem.getParent() == null) {
                backButton.setVisible(false);
                buttonsMap.keySet().forEach(mi -> {
                    buttonsMap.get(mi).setVisible(mi.getParent() == null);
                });
            } else {
                backButton.setVisible(true);
                buttonsMap.keySet().forEach(mi -> {
                    buttonsMap.get(mi).setVisible(mi.getParent() != null && mi.getParent().equals(focusedMenuItem.getParent()));
                });
            }
        }
    }

    @Subscribe
    public void updateBadge(final BadgeUpdateEvent event) {
        UI.getCurrent().access(() -> {
            buttonsMap.values().forEach(button -> {
                if (button.badgeId != null && button.badgeId.equals(event.getBadgeId())) {
                    button.setBadge(event.getBadgeValue());
                    button.markAsDirty();
                }
            });
            UI.getCurrent().push();
        });
    }

    @Subscribe
    public void onUserProfileRenderEvent(UserProfileRenderEvent event) {
        buildUserMenu();
    }
}

18 Source : SecurityView.java
with Apache License 2.0
from ijazfx

@Override
protected void postInitialize() {
    MenuBar menuBar = new MenuBar();
    MenuItem manageMenu = menuBar.addItem("Manage", null);
    manageMenu.addItem("User Accounts", event -> {
        securityGroupListPanel.setVisible(false);
        securityPolicyListPanel.setVisible(false);
        userAccountListPanel.setVisible(true);
        userAccountListPanel.refresh();
    });
    manageMenu.addItem("Security Groups", event -> {
        userAccountListPanel.setVisible(false);
        securityPolicyListPanel.setVisible(false);
        securityGroupListPanel.setVisible(true);
        securityGroupListPanel.refresh();
    });
    manageMenu.addItem("Security Policies", event -> {
        userAccountListPanel.setVisible(false);
        securityGroupListPanel.setVisible(false);
        securityPolicyListPanel.setVisible(true);
        userAccountListPanel.refresh();
    });
    addComponentsToToolbar(menuBar);
    addComponent(userAccountListPanel.build().withVisible(true));
    addComponent(securityGroupListPanel.build().withVisible(false));
    addComponent(securityPolicyListPanel.build().withVisible(false));
}

18 Source : LocalizationView.java
with Apache License 2.0
from ijazfx

@Override
protected void postInitialize() {
    MenuBar menuBar = new MenuBar();
    MenuItem manageMenu = menuBar.addItem("Manage", null);
    manageMenu.addItem("Supported Locales", event -> {
        termListPanel.setVisible(false);
        supportedLocaleListPanel.setVisible(true);
        supportedLocaleListPanel.refresh();
    });
    manageMenu.addItem("Terms", event -> {
        supportedLocaleListPanel.setVisible(false);
        termListPanel.setVisible(true);
        termListPanel.refresh();
    });
    addComponentsToToolbar(menuBar);
    addComponent(supportedLocaleListPanel.build().withVisible(false));
    addComponent(termListPanel.build().withVisible(true));
}

18 Source : SystemView.java
with Apache License 2.0
from ijazfx

@Override
protected void postInitialize() {
    MenuBar menuBar = new MenuBar();
    MenuItem manageMenu = menuBar.addItem("Manage", null);
    manageMenu.addItem("Namespaces", event -> {
        resourceListPanel.setVisible(false);
        namespaceListPanel.setVisible(true);
        namespaceListPanel.refresh();
    });
    manageMenu.addItem("Resources", event -> {
        namespaceListPanel.setVisible(false);
        resourceListPanel.setVisible(true);
        resourceListPanel.refresh();
    });
    addComponentsToToolbar(menuBar);
    addComponent(namespaceListPanel.build().withVisible(true));
    addComponent(resourceListPanel.build().withVisible(false));
}

7 Source : AbstractDashboardView.java
with Apache License 2.0
from ijazfx

private Component buildDashlet(final Component content) {
    final CssLayout slot = new CssLayout();
    slot.setWidth("100%");
    slot.addStyleName("dashboard-panel-slot");
    CssLayout card = new CssLayout();
    card.setWidth("100%");
    card.addStyleName(ValoTheme.LAYOUT_CARD);
    MHorizontalLayout toolbar = new MHorizontalLayout();
    toolbar.addStyleName("dashboard-panel-toolbar");
    toolbar.setWidth("100%");
    Label caption = new Label(content.getCaption());
    caption.addStyleName(ValoTheme.LABEL_H4);
    caption.addStyleName(ValoTheme.LABEL_COLORED);
    caption.addStyleName(ValoTheme.LABEL_NO_MARGIN);
    content.setCaption(null);
    MenuBar tools = new MenuBar();
    tools.addStyleName(ValoTheme.MENUBAR_BORDERLESS);
    MenuItem max = tools.addItem("", FontAwesome.EXPAND, new Command() {

        @Override
        public void menuSelected(final MenuItem selectedItem) {
            if (!slot.getStyleName().contains("max")) {
                selectedItem.setIcon(FontAwesome.COMPRESS);
                toggleMaximized(slot, true);
            } else {
                slot.removeStyleName("max");
                selectedItem.setIcon(FontAwesome.EXPAND);
                toggleMaximized(slot, false);
            }
        }
    });
    max.setStyleName("icon-only");
    MenuItem root = tools.addItem("", FontAwesome.ELLIPSIS_V, null);
    root.addItem("Configure", new Command() {

        @Override
        public void menuSelected(final MenuItem selectedItem) {
            Notification.show("Not implemented in this demo");
        }
    });
    root.addSeparator();
    root.addItem("Close", new Command() {

        @Override
        public void menuSelected(final MenuItem selectedItem) {
            Notification.show("Not implemented in this demo");
        }
    });
    toolbar.addComponents(caption, tools);
    toolbar.setExpandRatio(caption, 1);
    toolbar.setComponentAlignment(caption, Alignment.MIDDLE_LEFT);
    card.addComponents(toolbar, content);
    slot.addComponent(card);
    return slot;
}