Description Ed Burnette 2005-03-25 19:20:58 EST

3.1M5a. I know the Javadocs say 'experimental, do not use' but I needed to print
a sorted list of all commands known to the system and their keybindings (if any)
so I tried out the new workbench services for commands, keybindings, and
contexts. I'm finding it pretty hard to use as it's written.

For example, instead of getting a list of contexts, and for each context getting
a list of commands, I can only get a list of all commands so I iterate over all
the commands for each context, throwing out the ones for other contexts.

Another problem is that String ids are often returned when it would be more
convenient to just return the object it's an id for. I have to keep going back
to the service to ask for the meaning of ids, and also I find that I have to
build lookup tables (like KeysPreferencePage does). Also the concept of objects
existing but being undefined complicates the code. You've got services and
managers and the distinction isn't clear. You've also got an implementation of
commands over in org.eclipse.ui and another one in org.eclipse.core.commands
that looks a lot like the first one; sometimes searches pick up the wrong one
which is irritating. You've got things like CommandManager which doesn't
implement ICommandManager like one might think.

None of it feels very elegant. See the snippet below for the code I came up with
to do the dumping. Note I'm using the JDK5 syntax to try and simplify the code
but, it didn't really help much. See also bug 44156.


final ICommandService commandService = (ICommandService)
window.getWorkbench().getService(
        IWorkbenchServices.COMMAND);
IBindingService bindingService = (IBindingService) window.getWorkbench().getService(
        IWorkbenchServices.BINDING);
IContextService contextService = (IContextService) window.getWorkbench().getService(
        IWorkbenchServices.CONTEXT);
Set<Binding> allBindings = bindingService.getBindings();

List<String> categoryIds = new
ArrayList<String>(commandService.getDefinedCategoryIds());
Collections.sort(categoryIds, new Comparator<String>() {

    public int compare(String o1, String o2) {
        try {
            return commandService.getCategory(o1).getName().compareToIgnoreCase(
                    commandService.getCategory(o2).getName());
        } catch (NotDefinedException e) {
            return 0;
        }
    }
});

List<String> commandIds = new
ArrayList<String>(commandService.getDefinedCommandIds());
Collections.sort(commandIds, new Comparator<String>() {
    public int compare(String o1, String o2) {
        try {
            return commandService.getCommand(o1).getName().compareToIgnoreCase(
                    commandService.getCommand(o2).getName());
        } catch (NotDefinedException e) {
            return 0;
        }
    }
});
HashMap<String, List<Binding>> bindingsByCommandId = new HashMap<String,
List<Binding>>();
for (Binding binding : allBindings) {
    List<Binding> bindings = bindingsByCommandId.get(binding.getCommandId());
    if (bindings == null) {
        bindings = new LinkedList<Binding>();
    }
    bindings.add(binding);
    bindingsByCommandId.put(binding.getCommandId(), bindings);
}

for (String categoryId : categoryIds) {
    Category category = commandService.getCategory(categoryId);
    try {
        System.out.println("\nCategory: "
                + (category.isDefined() ? category.getName() : categoryId + "
undefined"));
        System.out.println("===========================");
        for (String commandId : commandIds) {
            Command command = commandService.getCommand(commandId);
            if (!command.isDefined()) {
                System.out.println(commandId + " undefined");
            } else {
                if (command.getCategory() != category)
                    continue;
                System.out.println(command.getName() + " (" +
command.getDescription()
                        + ")");
                List<Binding> bindings = bindingsByCommandId.get(commandId);
                if (bindings != null) {
                    Collections.sort(bindings, new Comparator<Binding>() {
                        public int compare(Binding o1, Binding o2) {
                            return
o1.getTriggerSequence().format().compareToIgnoreCase(
                                    o2.getTriggerSequence().format());
                        }
                    });
                    for (Binding binding : bindings) {
                        Scheme scheme =
bindingService.getScheme(binding.getSchemeId());
                        Context context =
contextService.getContext(binding.getContextId());
                        System.out.println("   "
                                + binding.getTriggerSequence().format()
                                + " ("
                                + (scheme.isDefined() ? scheme.getName() :
scheme.getId()
                                        + " undefined")
                                + ":"
                                + (context.isDefined() ? context.getName() : context
                                        .getId()
                                        + " undefined") + ":" +
binding.getLocale() + ":"
                                + binding.getPlatform() + ":" +
binding.getType() + ")");
                    }
                }
            }
        }
    } catch (NotDefinedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}


Sample output:

...
Category: Navigate
===========================
Back (Navigate back)
Backward History (Move backward in the editor navigation history)
   Alt+Left (Default:In Windows:null:null:0)
Forward (Navigate forward)
Forward History (Move forward in the editor navigation history)
   Alt+Right (Default:In Windows:null:null:0)
Go Into (Navigate into the selected item)
Go to Line (Go to a specified line of text)
   Ctrl+L (Default:Editing Text:null:null:0)
   Ctrl+X, G (Emacs:Editing Text:null:null:0)
...etc...