How do I build a JMenu dynamically (and not merely run-time creation)?

Question

To be clear, the several similar-appearing entries here DO NOT actually talk about building a menu dynamically since all their object name choices and such are already in their code as fixed strings already written in the source code; all they're doing is waiting until run-time to create their statically designed menu items. Here are two entries I found like that: One and Two. The concerns there merely had to do with the trivial (but vital) task of refreshing the display, NOT with anything like actual dynamic creation of content.

What I want to do, in sharp contrast, is to truly add dynamically: I want the user to be able to choose to add items to a sub-menu that they can then later select and have take action within the application.

Let's take the case of simply adding an integer value to a menu and then being able to select it later, similar to what can easily be done with a combo-box but instead done with a menu.

The problem isn't the syntax pertaining to defining, for example, a MenuListener that will point to a method that knows how to act, that's not the problem. Rather, I just don't know enough about the dynamic NAMING SPACE, and how to "de-reference" a String, for example, as an object name. Bluntly, how do I dynamically name my new objects that I didn't anticipate creating (not in kind but in number)? IOW, how do I take a cleverly constructed string that actually contains code I want run and then ask Java to run it? What's the Java syntax for that? Maybe the problem can be reduced to just object names; Say, the name comes as a string I can construct; how do use that in my JMenuItem declaration? ...I know how to do this in BASH, but how is this done in Java?

(I'm hoping I don't have to create it as a file, compile it, and somehow attach the class file(s) to my running program and then run it - DAMN that would be cumbersome!)

Thanks.

Answer 1

If I understand your overall intent, then I would recommend starting with the Actions API which be used to create independent units of work which are independent of how they are displayed.

This allows you to define re-usable (or in your case, dynamic) operations, which can be executed via menus, toolbars, buttons and even key bindings out of the box.

Because setting up a Action can be a little tedious, I might consider using a builder pattern, but you don't have to, you can build them manually if you wish ;)

public class ActionBuilder {
    private ActioBuilderAction action;

    public ActionBuilder() {
        action = new ActionBuilder.ActioBuilderAction();
    }

    public ActionBuilder toolTip(String text) {
        action.putValue(Action.SHORT_DESCRIPTION, text);
        return this;
    }

    public ActionBuilder command(String text) {
        action.putValue(Action.ACTION_COMMAND_KEY, text);
        return this;
    }

    public ActionBuilder mnemonic(int key) {
        action.putValue(Action.MNEMONIC_KEY, key);
        return this;
    }

    public ActionBuilder displayedMnemonicIndex(int index) {
        action.putValue(Action.DISPLAYED_MNEMONIC_INDEX_KEY, index);
        return this;
    }

    public ActionBuilder text(String text) {
        action.putValue(Action.NAME, text);
        return this;
    }

    public ActionBuilder smallIcon(Icon icon) {
        action.putValue(Action.SMALL_ICON, icon);
        return this;
    }

    public ActionBuilder largeIcon(Icon icon) {
        action.putValue(Action.LARGE_ICON_KEY, icon);
        return this;
    }

    public ActionBuilder acceleratorKey(KeyStroke ks) {
        action.putValue(Action.ACCELERATOR_KEY, ks);
        return this;
    }

    public ActionBuilder actionListener(ActionListener listener) {
        action.setListener(listener);
    }

    public Action build() {
        return action;
    }

    public class ActioBuilderAction extends AbstractAction {

        private ActionListener listener;

        public void setListener(ActionListener listener) {
            this.listener = listener;
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            if (listener != null) {
                listener.actionPerformed(e);
            }
        }

    }
}

Then, you could simply build a new menu something like...

Action action = new ActionBuilder().text("Super awesome command").actionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("Super aweseom comand GO!");
    }
}).build();

JMenuItem mi = new JMenuItem(action);

Now, I imagine, you might have a "command executor" class of some kind, which would. physically execute the command. I'd create a bridging class which implemented ActionListener and when it's called, would then execute the specified command

public class CommandListener implements ActionListener {
    private String command;

    public CommandListener(String command) {
        this.command = command;
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        CommandExecutor executor = new CommandExecutor();
        executor.execute(command)
    }


}

This could then be used in place of the ActionListener in the first example...

Action action = new ActionBuilder().text(commandName).actionListener(new CommandListener(command)).build();

As an overall idea