I've created a small piece of functionality that enables you to create actions for Java classes in
the IDE. When
the user right-clicks on a Java class, they will see one or more actions depending on
the superclass of
the selected class.
To explain this visually, here I have "BlaTopComponent.java". I right-click on its node in
the Projects window and I see "This is a TopComponent":
Indeed, when you look at
the source code of "BlaTopComponent.java", you'll see that it implements
the TopComponent class. Next, in
the screenshot below, you see that I have right-click a different class. In this case, there's an action available because
the selected class implements
the ActionListener class.
Then, take a look at this one. Here both TopComponent and ActionListener are superclasses of
the current class, hence both
the actions are available to be invoked:
Finally, here's a class that subclasses neither TopComponent nor ActionListener, hence neither of
the actions that I created for doing something that relates to TopComponents or ActionListeners is available, since those actions are irrelevant in this context:
How does this work? Well, it's a combination of my blog entries "Generic Node Popup Registration Solution" and "Showing an Action on a TopComponent Node".
The cool part is that
the definition of
the two actions that you see above is remarkably trivial:
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JOptionPane;
import org.openide.loaders.DataObject;
import org.openide.util.Utilities;
public class TopComponentSensitiveAction implements ActionListener {
private final DataObject context;
public TopComponentSensitiveAction() {
context = Utilities.actionsGlobalContext().lookup(DataObject.class);
}
@Override
public
void actionPerformed(ActionEvent ev) {
//Do something with
the context:
JOptionPane.showMessageDialog(null, "TopComponent: " +
context.getNodeDelegate().getDisplayName());
}
}
The above is
the action that will be available if you right-click a Java class that extends TopComponent. This, in turn, is
the action that will be available if you right-click a Java class that implements ActionListener:
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JOptionPane;
import org.openide.loaders.DataObject;
import org.openide.util.Utilities;
public class ActionListenerSensitiveAction implements ActionListener {
private final DataObject context;
public ActionListenerSensitiveAction() {
context = Utilities.actionsGlobalContext().lookup(DataObject.class);
}
@Override
public
void actionPerformed(ActionEvent ev) {
//Do something with
the context:
JOptionPane.showMessageDialog(null, "ActionListener: " +
context.getNodeDelegate().getDisplayName());
}
}
Indeed,
the classes, at this stage are
the same. But, depending on what I want to do with TopComponents or ActionListeners, I now have a starting point, which includes access to
the DataObject, from where I can get down into
the source code, as shown here.
This is how
the two ActionListeners that you see defined above are registered in
the layer, which could ultimately be done via annotations on
the ActionListeners, of course:
<folder name="Actions">
<folder name="Tools">
<file name="org-netbeans-sbas-impl-TopComponentSensitiveAction.instance">
<attr stringvalue="This is a TopComponent" name="displayName"/>
<attr name="instanceCreate"
methodvalue="org.netbeans.sbas.SuperclassSensitiveAction.create"/>
<attr name="type" stringvalue="org.openide.windows.TopComponent"/>
<attr name="delegate"
newvalue="org.netbeans.sbas.impl.TopComponentSensitiveAction"/>
</file>
<file name="org-netbeans-sbas-impl-ActionListenerSensitiveAction.instance">
<attr stringvalue="This is an ActionListener" name="displayName"/>
<attr name="instanceCreate"
methodvalue="org.netbeans.sbas.SuperclassSensitiveAction.create"/>
<attr name="type" stringvalue="java.awt.event.ActionListener"/>
<attr name="delegate"
newvalue="org.netbeans.sbas.impl.ActionListenerSensitiveAction"/>
</file>
</folder>
</folder>
<folder name="Loaders">
<folder name="text">
<folder name="x-java">
<folder name="Actions">
<file name="org-netbeans-sbas-impl-TopComponentSensitiveAction.shadow">
<attr name="originalFile"
stringvalue="Actions/Tools/org-netbeans-sbas-impl-TopComponentSensitiveAction.instance"/>
<attr intvalue="150" name="position"/>
</file>
<file name="org-netbeans-sbas-impl-ActionListenerSensitiveAction.shadow">
<attr name="originalFile"
stringvalue="Actions/Tools/org-netbeans-sbas-impl-ActionListenerSensitiveAction.instance"/>
<attr intvalue="160" name="position"/>
</file>
</folder>
</folder>
</folder>
</folder>
The most important parts of
the layer registration are
the lines that are highlighted above. Those lines connect
the layer to
the generic action that delegates back to
the action listeners defined above, as follows:
public final class SuperclassSensitiveAction extends AbstractAction implements ContextAwareAction {
private final Map map;
//This method is called from
the layer, via "instanceCreate",
//magically receiving a map, which contains all
the attributes
//that are defined in
the layer for
the file:
static SuperclassSensitiveAction create(Map map) {
return new SuperclassSensitiveAction(Utilities.actionsGlobalContext(), map);
}
public SuperclassSensitiveAction(Lookup context, Map m) {
super(m.get("displayName").toString());
this.map = m;
String superclass = m.get("type").toString();
//Enable
the menu item only if
//we're dealing with a class of type superclass:
JavaSource javaSource = JavaSource.forFileObject(
context.lookup(DataObject.class).getPrimaryFile());
try {
javaSource.runUserActionTask(new ScanTask(this, superclass), true);
} catch (IOException ex) {
Exceptions.printStackTrace(ex);
}
//Hide
the menu item if it isn't enabled:
putValue(DynamicMenuContent.HIDE_WHEN_DISABLED, true);
}
@Override
public
void actionPerformed(ActionEvent ev) {
ActionListener delegatedAction = (ActionListener)map.get("delegate");
delegatedAction.actionPerformed(ev);
}
@Override
public Action createContextAwareInstance(Lookup actionContext) {
return new SuperclassSensitiveAction(actionContext, map);
}
private class ScanTask implements Task<CompilationController> {
private SuperclassSensitiveAction action = null;
private String superclass;
private ScanTask(SuperclassSensitiveAction action, String superclass) {
this.action = action;
this.superclass = superclass;
}
@Override
public
void run(final CompilationController info) throws Exception {
info.toPhase(Phase.ELEMENTS_RESOLVED);
new EnableIfGivenSuperclassMatches(info, action, superclass).scan(
info.getCompilationUnit(), null);
}
}
private static class EnableIfGivenSuperclassMatches extends TreePathScanner<Void, Void> {
private CompilationInfo info;
private final AbstractAction action;
private final String superclassName;
public EnableIfGivenSuperclassMatches(CompilationInfo info,
AbstractAction action,
String superclassName) {
this.info = info;
this.action = action;
this.superclassName = superclassName;
}
@Override
public
Void visitClass(ClassTree t,
Void v) {
Element el = info.getTrees().getElement(getCurrentPath());
if (el != null) {
TypeElement te = (TypeElement) el;
List<? extends TypeMirror> interfaces = te.getInterfaces();
if (te.getSuperclass().toString().equals(superclassName)) {
action.setEnabled(true);
} else {
action.setEnabled(false);
}
for (TypeMirror typeMirror : interfaces) {
if (typeMirror.toString().equals(superclassName)){
action.setEnabled(true);
}
}
}
return null;
}
}
}
This is a pretty cool solution and, as you can see, very generic. Create a new ActionListener, register it in
the layer so that it maps to
the generic class above, and make sure to set
the type attribute, which defines
the superclass to which
the action should be sensitive.
