如何让natTable表格支持自定义多个右键菜单

在nebula中，官方默认提供了一个构造natTable的builder类，并且提供了一个debugInfo的默认右键菜单，但是当我们通过官方提供的builder去创建natTable，并且要添加多个右键菜单的时候，显得就不太灵活了，需要自己动手改改了，直接上代码吧：

1、创建一个抽象的菜单类AbstractMenuConfiguration：

public abstract class AbstractMenuConfiguration implements IMenuItemProvider {

    private final String NAT_EVENT_DATA_KEY = "natEventData"; //$NON-NLS-1$

    @Override
    public void addMenuItem(NatTable natTable, Menu popupMenu) {
        MenuItem inspectLabelsMenuItem = new MenuItem(popupMenu, SWT.PUSH);
        inspectLabelsMenuItem.setText(getMenuName());
        inspectLabelsMenuItem.setEnabled(true);
        inspectLabelsMenuItem.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent e) {
                processEvent(getNatEventData(e));
            }
        });
    }

    private NatEventData getNatEventData(SelectionEvent selectionEvent) {
        Widget widget = selectionEvent.widget;
        if (widget == null || !(widget instanceof MenuItem)) {
            return null;
        }

        MenuItem menuItem = (MenuItem) widget;
        Menu parentMenu = menuItem.getParent();
        Object data = null;
        while (parentMenu != null) {
            if (parentMenu.getData(this.NAT_EVENT_DATA_KEY) == null) {
                parentMenu = parentMenu.getParentMenu();
            } else {
                data = parentMenu.getData(this.NAT_EVENT_DATA_KEY);
                break;
            }
        }

        return data != null ? (NatEventData) data : null;
    }

    protected abstract void processEvent(NatEventData natEventData);

    protected abstract String getMenuName();
}

2、创建一个自定义PopupMenu构建类CustomerPopupMenuBuilder：

public class CustomerPopupMenuBuilder {

    /**
     * The active NatTable instance the context menu should be added to. Needed
     * in advance to be able to add custom menu items that need the NatTable
     * instance.
     */
    protected NatTable natTable;

    /**
     * The {@link Menu} that is created with this popup menu builder.
     */
    protected Menu popupMenu;

    /**
     * The {@link MenuManager} that is used by this popup menu builder. Can be
     * <code>null</code> if plain SWT menu mechanisms are used.
     */
    protected MenuManager menuManager;

    /**
     * Collection of all registered visibility state checkers for configured
     * id's.
     */
    protected final MenuItemStateMap visibility = new MenuItemStateMap();

    /**
     * Collection of all registered enablement state checkers for configured
     * id's.
     */
    protected final MenuItemStateMap enablement = new MenuItemStateMap();

    /**
     * Creates {@link CustomerPopupMenuBuilder} that builds up a new
     * {@link Menu} that is only configurable with this instance of
     * {@link CustomerPopupMenuBuilder}. Uses a {@link MenuManager} internally
     * to be able to configure visibility and enabled states.
     *
     * @param parent
     *            The active NatTable instance the context menu should be added
     *            to.
     */
    public CustomerPopupMenuBuilder(NatTable parent) {
        this(parent, new MenuManager());
    }

    /**
     * Creates a {@link CustomerPopupMenuBuilder} that builds up a new
     * {@link Menu} using the given {@link MenuManager}.
     *
     * @param parent
     *            The active NatTable instance the context menu should be added
     *            to.
     * @param manager
     *            The {@link MenuManager} that should be used to create the
     *            {@link Menu}.
     */
    public CustomerPopupMenuBuilder(NatTable parent, MenuManager manager) {
        this.natTable = parent;
        this.menuManager = manager;
        this.popupMenu = manager.createContextMenu(this.natTable);
    }

    /**
     * Creates a popup menu builder based on the given menu. Using this enables
     * the possibility to use configured context menus from plugin.xml and
     * adding NatTable commands programmatically.
     * <p>
     * As an example you might want to create a PopupMenuBuilder by using a
     * configured menu with the id
     * <i>org.eclipse.nebula.widgets.nattable.example.contextmenu</i>
     * <p>
     *
     * <pre>
     * ISelectionProvider isp =
     *         new RowSelectionProvider&lt;?&gt;(selectionLayer, bodyDataProvider, false);
     * MenuManager menuManager = new MenuManager();
     * menuManager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
     * getSite().registerContextMenu(
     *         &quot;org.eclipse.nebula.widgets.nattable.example.contextmenu&quot;, menuManager, isp);
     * PopupMenuBuilder popupMenu =
     *         new PopupMenuBuilder(menuManager.createContextMenu(natTable));
     * </pre>
     * <p>
     * For usage with Eclipse 4 you can use the <code>EMenuService</code> to
     * register the menu to a NatTable instance. Afterwards get the menu and
     * remove it from the NatTable to avoid the SWT control menu. The generated
     * menu carries a {@link MenuManager} in the {@link Menu#getData()} which
     * will be used within this {@link CustomerPopupMenuBuilder}.
     * </p>
     *
     * <pre>
     * menuService.registerContextMenu(natTable, menuId);
     * Menu swtMenu = natTable.getMenu();
     * natTable.setMenu(null);
     * </pre>
     *
     * @param natTable
     *            The active NatTable instance which might be needed for
     *            creation of menu items that need the NatTable instance to
     *            work.
     * @param menu
     *            The registered context menu.
     */
    public CustomerPopupMenuBuilder(NatTable natTable, Menu menu) {
        this.natTable = natTable;
        this.popupMenu = menu;

        // if the menu is build up using a MenuManager, remember that for
        // further use
        if (menu.getData() != null && menu.getData() instanceof MenuManager) {
            this.menuManager = (MenuManager) menu.getData();
        }
    }

    /**
     * Adds the menu item provided by the given {@link IMenuItemProvider} to the
     * popup menu. You can use this to add your own item to the popup menu.
     * <p>
     * Items added by this method can not be identified by id, so adding visible
     * or enabled state checkers is not possible for these providers.
     * </p>
     *
     * @param menuItemProvider
     *            The {@link IMenuItemProvider} that provides the menu item that
     *            should be added to the popup menu.
     * @return The current {@link CustomerPopupMenuBuilder} with the added item.
     */
    public CustomerPopupMenuBuilder withMenuItemProvider(IMenuItemProvider menuItemProvider) {
        if (this.menuManager == null) {
            menuItemProvider.addMenuItem(this.natTable, this.popupMenu);
        } else {
            this.menuManager.add(new PopupContributionItem(menuItemProvider));
        }
        return this;
    }

    /**
     * Adds the menu item provided by the given {@link IMenuItemProvider} to the
     * popup menu. You can use this to add your own item to the popup menu.
     * <p>
     * As items added by this method can be identified via the given id it is
     * possible to register visible or enabled state checkers for these
     * providers.
     * </p>
     *
     * @param id
     *            The id under which the given {@link IMenuItemProvider} should
     *            be identifiable.
     * @param menuItemProvider
     *            The {@link IMenuItemProvider} that provides the menu item that
     *            should be added to the popup menu.
     * @return The current {@link CustomerPopupMenuBuilder} with the added item.
     */
    public CustomerPopupMenuBuilder withMenuItemProvider(String id, IMenuItemProvider menuItemProvider) {
        if (this.menuManager == null) {
            menuItemProvider.addMenuItem(this.natTable, this.popupMenu);
        } else {
            this.menuManager.add(new PopupContributionItem(id, menuItemProvider));
        }
        return this;
    }

    /**
     * Adds the menu item(s) provided by the given {@link ContributionItem} to
     * the popup menu. You can use this to add your own item to the popup menu.
     * <p>
     * This method is only working if the {@link CustomerPopupMenuBuilder} is
     * using a {@link MenuManager}.
     * </p>
     * <p>
     * Using this adds support for visibility and enabled states of menu items.
     * </p>
     *
     * @param contributionItem
     *            The {@link ContributionItem} that is used to add a menu item
     *            to the menu.
     * @return The current {@link CustomerPopupMenuBuilder} with the added item.
     * @throws IllegalStateException
     *             if this {@link CustomerPopupMenuBuilder} does not use a
     *             {@link MenuManager}
     */
    public CustomerPopupMenuBuilder withContributionItem(ContributionItem contributionItem) {
        if (this.menuManager == null) {
            throw new IllegalStateException("This PopupMenuBuilder is not created using a MenuManager, " //$NON-NLS-1$
                    + "therefore ContributionItems can not be added"); //$NON-NLS-1$
        } else {
            this.menuManager.add(contributionItem);
        }
        return this;
    }

    public CustomerPopupMenuBuilder configureMenuItemProvider(String mid, IMenuItemProvider menuItemProvider) {
        return withMenuItemProvider(
                mid,
                menuItemProvider);
    }

    /**
     * Adds a separator to the popup menu with the given id.
     *
     * @param id
     *            The id to identify the separator. Necessary if there should be
     *            visibility constraints for specific separators.
     * @return The {@link CustomerPopupMenuBuilder} with an added separator.
     * @see MenuItemProviders#separatorMenuItemProvider()
     */
    public CustomerPopupMenuBuilder withSeparator(String id) {
        return withMenuItemProvider(id, MenuItemProviders.separatorMenuItemProvider());
    }

    /**
     * Builds and returns the created {@link Menu}.
     * <p>
     * <b>Note:</b> Calling this method will also add a {@link DisposeListener}
     * to the NatTable instance to ensure the created {@link Menu} is disposed
     * when the NatTable itself gets disposed.
     * </p>
     *
     * @return The {@link Menu} that is created by this builder.
     */
    public Menu build() {

        this.natTable.addDisposeListener(new DisposeListener() {
            @Override
            public void widgetDisposed(DisposeEvent e) {
                if (CustomerPopupMenuBuilder.this.popupMenu != null
                        && !CustomerPopupMenuBuilder.this.popupMenu.isDisposed())
                    CustomerPopupMenuBuilder.this.popupMenu.dispose();
            }
        });

        return this.popupMenu;
    }

    /**
     * Associate a visibility {@link IMenuItemState} with the menu item
     * identified by the given id.
     * <p>
     * The visibility state is handled by the internal {@link MenuManager}. If
     * no {@link MenuManager} is used, this method will have not effect.
     * </p>
     * <p>
     * For the item to be visible, all associated {@link IMenuItemState} must be
     * active OR no {@link IMenuItemState} must be associated with the item.
     * </p>
     *
     * @param id
     *            the registered {@link IMenuItemState} will affect the menu
     *            item identified by the given id.
     * @param state
     *            the {@link IMenuItemState} to queried for the visibility state
     *            of the menu item with the given id.
     * @return This {@link CustomerPopupMenuBuilder} with the visible state
     *         checker for the given id.
     */
    public CustomerPopupMenuBuilder withVisibleState(String id, IMenuItemState state) {
        this.visibility.addMenuItemState(id, state);
        return this;
    }

    /**
     * Associate a enabled {@link IMenuItemState} with the menu item identified
     * by the given id.
     * <p>
     * The enabled state is handled by the internal {@link MenuManager}. If no
     * {@link MenuManager} is used, this method will have not effect.
     * </p>
     * <p>
     * For the item to be enabled, all associated {@link IMenuItemState} must be
     * active OR no {@link IMenuItemState} must be associated with the item.
     * </p>
     *
     * @param id
     *            the registered {@link IMenuItemState} will affect the menu
     *            item identified by the given id.
     * @param state
     *            the {@link IMenuItemState} to queried for the enabled state of
     *            the menu item with the given id.
     * @return This {@link CustomerPopupMenuBuilder} with the enabled state
     *         checker for the given id.
     */
    public CustomerPopupMenuBuilder withEnabledState(String id, IMenuItemState state) {
        this.enablement.addMenuItemState(id, state);
        return this;
    }

    /**
     * Wrapper class to build up a {@link ContributionItem} based on a given
     * {@link IMenuItemProvider}. If an id is set it is possible to register
     * state checkers for enabled and visible state.
     */
    protected class PopupContributionItem extends ContributionItem {

        private IMenuItemProvider provider;

        public PopupContributionItem(IMenuItemProvider provider) {
            this(null, provider);
        }

        public PopupContributionItem(String id, IMenuItemProvider provider) {
            super(id);
            this.provider = provider;
        }

        @Override
        public void fill(Menu menu, int index) {
            List<MenuItem> beforeItems = Arrays.asList(menu.getItems());
            this.provider.addMenuItem(CustomerPopupMenuBuilder.this.natTable, menu);
            MenuItem[] afterItems = menu.getItems();

            for (MenuItem item : afterItems) {
                if (!beforeItems.contains(item)) {
                    // isEnabled() seems to be not called by the framework on
                    // opening a menu therefore we set it ourself. For this we
                    // also need to ensure isDynamic() returns true for
                    // re-rendering.
                    item.setEnabled(isEnabled());
                }
            }
        }

        @Override
        public boolean isDynamic() {
            return (getId() != null);
        }

        @Override
        public boolean isEnabled() {
            if (getId() != null) {
                Object eventData = CustomerPopupMenuBuilder.this.popupMenu.getData(MenuItemProviders.NAT_EVENT_DATA_KEY);
                if (eventData != null && eventData instanceof NatEventData) {
                    return CustomerPopupMenuBuilder.this.enablement.isActive(getId(), (NatEventData) eventData);
                }
            }
            return true;
        }

        @Override
        public boolean isVisible() {
            if (getId() != null) {
                Object eventData = CustomerPopupMenuBuilder.this.popupMenu.getData(MenuItemProviders.NAT_EVENT_DATA_KEY);
                if (eventData != null && eventData instanceof NatEventData) {
                    return CustomerPopupMenuBuilder.this.visibility.isActive(getId(), (NatEventData) eventData);
                }
            }
            return true;
        }

    }
}

3、实现自定义多右键菜单配置CustomerPopupMenuConfiguration：

public class CustomerPopupMenuConfiguration extends AbstractUiBindingConfiguration {

    private Menu menu;

    private CustomerPopupMenuBuilder customerPopupMenuBuilder;

    public CustomerPopupMenuConfiguration(NatTable natTable) {
        this.customerPopupMenuBuilder = new CustomerPopupMenuBuilder(natTable);

    }

    public CustomerPopupMenuConfiguration configureMenuItemProvider(String mid, IMenuItemProvider menuItemProvider) {
        this.customerPopupMenuBuilder.configureMenuItemProvider(mid, menuItemProvider);
        return this;
    }

    public CustomerPopupMenuConfiguration build() {
        this.menu = this.customerPopupMenuBuilder.build();
        return this;
    }

    @Override
    public void configureUiBindings(UiBindingRegistry uiBindingRegistry) {
        uiBindingRegistry.registerMouseDownBinding(
                new MouseEventMatcher(SWT.NONE, null, 3),
                new PopupMenuAction(this.menu));
    }
}

4、后面剩下的就是怎么使用自定义菜单了配置了：

public  class Test{
      public void configure(NatTable natTable){
     ......  
              natTable.addConfiguration(new CustomerPopupMenuConfiguration(natTable).configureMenuItemProvider("addRowMenuItem", new AbstractMenuConfi           guration(){
            @Override
            protected String getMenuName() {
                return "add";
            }
            @Override
            protected void processEvent(NatEventData natEventData) {
                //处理增加
            }
        }).configureMenuItemProvider("updateRowMenuItem", new AbstractMenuConfiguration(){
            @Override
            protected String getMenuName() {
                return "update";
            }
            @Override
            protected void processEvent(NatEventData natEventData) {
                    //  处理修改
            }
        }).configureMenuItemProvider("deleteRowMenuItem", new AbstractMenuConfiguration(){
            @Override
            protected String getMenuName() {
                return "delete";
            }
            @Override
            protected void processEvent(NatEventData natEventData) {
                //处理删除
            }
        }).build());
     .....  
     }      
}

以上就实现了灵活自定义右键菜单。