Extreme Java When vanilla Java is not enough


Custom project file structure in NetBeans – new menu item in projects

In a previous post, I’ve told that I want to use NetBeans and share projects with developers that still use Eclipse. In another post, I added a custom folder to the project view.

Now, I will add a custom menu item to run an ant task outside NB's build scripts:

  1. Assuming you have a NB module project ready, you just need to add a new entry in your layer.xml:
    <folder name="Projects">
      <folder name="Actions">
        <file name="org-mycompany-MyMenuAction.instance"/>
  2. Create a new class with the same name (org.mycompany.MyMenuAction):
    public final class TransitMenuAction
      extends AbstractAction
      implements Presenter.Popup, ContextAwareAction {
      public final static String DISPLAY_NAME =
      private Lookup context;
      public TransitMenuAction() {
      public TransitMenuAction(Lookup context) {
        this.context = context;
      public void actionPerformed(ActionEvent e) {
        // I'm a menu container... I do nothing
      public Action createContextAwareInstance(
        Lookup context) {
        return new MyMenuAction(context);
      public JMenuItem getPopupPresenter() {
        return new PopupPresenter();
      /** Dynamic menu factory */
      class PopupPresenter extends JMenuItem
        implements DynamicMenuContent {
        public JComponent[] getMenuPresenters() {
          Project proj = context.lookup(Project.class);
          // MyUtils comes from last post
          if (!MyUtils.isMyProject(proj)) {
            // hides this menu
            return new JComponent[0];
          JMenu mnu = new JMenu(DISPLAY_NAME);
          mnu.add(new PackageAction(context));
          return new JComponent[] { mnu };
        public JComponent[] synchMenuPresenters(
          JComponent[] items) {
          return items;
  3. And, the PackageAction is:
    public class PackageAction extends AbstractAction {
      private Lookup context;
      public PackageAction(Lookup context) {
        this.context = context;
      /* This action will copy a file and run an Ant task */
      public void actionPerformed(ActionEvent e) {
        try {
          /* Both the file and the build scripts are under
           * the "ant" folder in project directory
          Project proj = context.lookup(Project.class);
          FileObject antFolder = proj.getProjectDirectory().
          // Read the original file
          FileObject def = antFolder.
          Properties prop = new Properties();
          // Change a little bit
          // TODO: Add this to a property window
          // Write to the copy file
          FileObject cpy = antFolder
          if (cpy == null) {
            cpy = antFolder.createData("compile.properties");
          FileLock lock = cpy.lock();
          try {
              "any cool comment");
          } finally {
          // Now, we will run Ant - grab the script...
          FileObject buildXML = antFolder
          // ... and run the "package" target
             new String[]{ "package" }, null);
        } catch (IOException ex) {
        } catch (IllegalArgumentException ex) {
  4. Last, but not least, the project dependencies:
    1. Ant (ActionUtils)
    2. Filesystem API (FileObject and FileLock);
    3. Project API (Project);
    4. UI Utilities API (DynamicMenuContent); and
    5. Utilities API (Lookup)

And, your new project menu item (that calls an Ant task) is ready.

Comments (0) Trackbacks (0)

No comments yet.

Leave a comment



No trackbacks yet.