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.


Custom project file structure in NetBeans

In my job, they officially use Eclipse Europa to develop. I really dislike Eclipse - it is a matter of taste. Because of this, I'm using NetBeans ability to share projects (like in this demo) - and it works like a charm.

But, since even rose has its thorn, they have some custom tasks here:

  1. Inside every project, there's a "config" folder with some files that must be copied to a "/var/xxx" folder before running the application;
  2. A custom ant build script to create a ZIP file that will go to test and production environments; and
  3. The file from step 2 must be transfered via SFTP to specific servers, on a folder named like "/var/deploy/xxx".

These are manually-repeated tasks that must be done for every project. Eclipse users (here) must do it step-by-step. NetBeans users will use a (custom) brand-new module that I developed to do these tasks.

Just to enumerate, we need to solve these problems:

  1. The "config" folder must be visible in "Projects" tab (it is under "Files" tab, but it is ugly);
  2. An ant task in a custom build script must be called whenever I want;
  3. The "config" folder must be copied to "/var/xxx" when the project is compiled;
  4. An ZIP file must be sent via SFTP to a "/var/deploy/xxx" folder;
  5. I don't want to hardcode the "xxx" - what about a new tab on project properties?

OK. We have a lot of things to cover here. But, they are very simple. Since it could become a large post, I'll cover them in other posts (that will be have a pingback here, on comments section).