Many bug fixes and several improvements are featured in the Beta release:

• [REDMINENB-1] – New Issue: Casting exception leads to messed up UI
• [REDMINENB-2] – Update issue: Hours cast Long->Double exception
• [REDMINENB-6] – Implement add comment (used from commit dialog box)
• [REDMINENB-7] – Class Cast Exception makes UI unusable
• [REDMINENB-11] – Can’t create Redmine issue tracker
• [REDMINENB-16] – Exception occurs when specifying parent task number
• [REDMINENB-3] – Update issue: Give feedback when successfully updated
• [REDMINENB-19] – Add Update Center

Since RedmineNB has an implementation dependency to the Issue Tracking module the plugin is only compatible with NetBeans 7.1.1. A Redmine V1.3.0+ installation is required for best compatibility (tested with V1.3.1 and V1.4.0). There are some limitations in the functionality since the used Redmine REST API is not yet fully developed.

The plugin can be downloaded from the RedmineNB project@kenai or installed by the new Update Center:

• Name: RedmineNB Update Center
• URL: http://kenai.com/projects/redminenb/sources/redminenb/content/trunk/dist/updates/updates.xml?raw=true

The downloaded distribution also installs the Update Center for automatically receive updates. For more information please consult the project’s Wiki. Please report bugs and feature request in the project’s JIRA.

Please note that RedmineNB is still under development and not intended for production use.

Update (2012-04-25):

The “Can’t find resource for bundle …”-Problem has been fixed with Version 1.0.7 (available fron the Update Center).

/**
 * @see org.openide.awt.Actions#connect(AbstractButton, Action)
 */
@ServiceProvider(service = ButtonActionConnector.class, position = 100)
public class MyButtonActionConnector implements ButtonActionConnector {

   @Override
   public boolean connect(AbstractButton button, Action action) {
      String text = (String)action.getValue("menuText"); // NOI18N
      if (text != null) {
         button.setAction(action);
         button.setText(Actions.cutAmpersand(text));
         String desc = (String)action.getValue(Action.SHORT_DESCRIPTION);
         if (desc != null) {
            button.setToolTipText(desc);
         } else {
            button.setToolTipText((String)action.getValue(Action.NAME));
         }
         return true;
      }
      return false;
   }

   @Override
   public boolean connect(JMenuItem item, Action action, boolean popup) {
      return false; // use default implementation
   }
}

If the property menuText is set, the the button is configured with icon and text. The basic use of the menuText Property is (copied from @ActionRegistration‘s javadoc):

Provides the JMenuItem text if one wants to use other than the name of the action returned by ActionRegistration.displayName().

With the custom ButtonActionConnector this property is “extended” to show a toolbar button text if supplied.

Provide a value for the @ActionRegistration’s menuText Attribute for the desired action(s):

@ActionRegistration(displayName = "#CTL_PwdChangeAction",
                    menuText = "#CTL_PwdChangeAction",
                    iconBase = "resources/key1.png")
@ActionReference(path = "Toolbars/User")
@Messages("CTL_PwdChangeAction=Change Password…")
public final class PwdChangeAction implements ActionListener {
   ...
}

Result:

or

Tested with NetBeans 7.1.1 (see comments)

InstanceContent ic = new InstanceContent();
Lookup lkp = new AbstractLookup(ic);

The fastest way to clear all the Lookup contents:

ic.set(Collections.emptyList(), null);

Now I’m looking for a convenience command to remove all instances of a given type. I want to replace this code:

for (MyClass my : lkp.lookupAll(MyClass.class)) {  
   ic.remove(my);
}

Since RedmineNB has an implementation dependency to the Issue Tracking module the plugin is only compatible with NetBeans 7.1.1. A Redmine V1.3.0+ installation is required for best compatibility (tested with V1.3.1). There are some limitations in the functionality since the used Redmine REST API is not yet fully developed. This page gives an overview of the Redmine REST API.

The plugin can be downloaded from the RedmineNB project@kenai and for more information consult the project’s Wiki. Please note that RedmineNB is still under development and not yet intended for production use.

New and noteworthy in V1.1.19

• Update Center integration
• Added new actions to the Project folder sub menu:
  
• The “Open in System” behavior can be configured in the new Options Panel:
  
• The NetBeans Default implementation of “Open in System” depends on the Java Desktop API. On the SunOS and Linux Platforms, this API is dependent on Gnome libraries. If those libraries are unavailable, the Desktop API is not available. But now you can define Custom Commands for opening files and folders! The Command of the general File Type “file” is used if no special command is set to the specific MIME Type of a file.
  

The Plugin is compatible with NetBeans 7.1 and can be downloaded from here:

• Kenai Project
• Plugin Portal @ netbeans.org

Other improvements:

• The Button’s Popup Menu is lazy loaded
• Improved Open & Select Project action
• Added Close Project action
• minor bug fixes

The Plugin can be downloaded from here:

• Kenai Project
• Plugin Portal @ netbeans.org

The plugin can be downloaded from the Kenai Project site. Feel free to write me some feedback!

I will submit this plugin in the next few days also to the NetBeans Plugin Portal.

An explicit Toolbar API isn’t available in the NetBeans Platform. The class org.openide.awt.ToolbarPool is used to install and update the configured toolbars. With the constructor public ToolbarPool(DataFolder df) an own toolbar configuration at the specified location in the layer.xml (DataFolder) can be created.

But I don’t want create a new toolbar configuration for each TopComponent who should have their own toolbars. The idea is:

1. Declare the toolbar for the TopComponent at a certain location (!= Toolbars/) in the module’s layer.xml
2. Register the toolbar in the active toolbar configuration
3. show the toolbar on TopComponent#componentOpened()
4. hide the toolbar on TopComponent#componentClosed()

All these steps should be performed dynamically at runtime. How can I achieve this? Let’s go ahead…

Declare the toolbar

<!-- file: layer.xml -->
<filesystem>
   ...
   <folder name="MyModule">
      <folder name="Toolbars">
         <folder name="MyToolbar">
            <attr name="displayName" stringvalue="My Toolbar" />
            <file name="my-action-1.instance">
               ...
            </file>
         </folder>
      </folder>
   </folder>
</filesystem>

Register the toolbar in the active toolbar configuration
Using a shadow entry any custom toolbar is registered once in the default toolbar pool (at Toolbars/):

public static boolean registerToolbar(String toolbarConfigPath) {
   try {
      FileObject fo = FileUtil.getConfigFile(toolbarConfigPath);
      if (fo == null) {
         return false;
      }
      DataFolder df = DataFolder.findFolder(fo);
      DataFolder target = ToolbarPool.getDefault().getFolder();
      FileObject targetFO = target.getPrimaryFile().getFileObject(fo.getNameExt() + ".shadow");

      if (df != null && targetFO == null) {
         DataShadow ds = df.createShadow(target);
         return true;
      }
   } catch (IOException ex) {
      Exceptions.printStackTrace(ex);
   }
   return false;
}

Show/hide the toolbar
For programatically hide and show a toolbar you can write:

Toolbar toolbar = ToolbarPool.getDefault().findToolbar("MyToolbar");
toolbar.getParent().setVisible(false);

After debugging I found this solution (or hack):

public static void setToolbarVisible(Toolbar toolbar, boolean visible) {
   try {
      ClassLoader cl = Lookup.getDefault().lookup(ClassLoader.class);
      Class cToolbarConfiguration = cl.loadClass("org.netbeans.core.windows.view.ui.toolbars.ToolbarConfiguration");
      // invoke static ToolbarConfiguration.findConfiguration( String name)
      Object toolbarConfig = cToolbarConfiguration.getMethod("findConfiguration", String.class).
              invoke(cToolbarConfiguration, "Standard");
      // invoke ToolbarConfiguration#setToolbarVisible( Toolbar tb, boolean visible)
      toolbarConfig.getClass().getMethod("setToolbarVisible", Toolbar.class, boolean.class).invoke(toolbarConfig, toolbar, visible);
   } catch (Exception ex) {
      throw new IllegalArgumentException(ex);
   }
}

Link the toolbar together with the TopComponent’s visibility state (simplified):

String toolbarName = "MyToolbar";

public final void componentOpened() {
   ToolbarUtil.registerToolbar("MyModule/Toolbars/" + toolbarName);
   ToolbarUtil.setToolbarVisible(toolbarName, true);
}

public final void componentClosed() {
  ToolbarUtil.setToolbarVisible(toolbarName, false);
}

netbeans.winsys.statusLine.in.menuBar=true

# Options used by NetBeans launcher by default, can be overridden by explicit
# command line switches:
netbeans_default_options="-J-client -J-Xss2m -J-Xms32m -J-Xmx1500m -J-XX:PermSize=32m -J-XX:MaxPermSize=400m -J-Dapple.laf.useScreenMenuBar=true -J-Dsun.java2d.noddraw=true -J-Dnetbeans.winsys.statusLine.in.menuBar=true"

Don’t forget to add -J-D before the property name!

See also FaqNetbeansConf

The Simple Validation API gives you a convenience method to show a dialog like (excerpt from the BasicDemo):

JPanel panel = new JPanel();
... // setup panel

ValidationPanel vp = new ValidationPanel();
vp.setInnerComponent(panel);
... // setup validation

// Convenience method to show a simple dialog
if (vp.showOkCancelDialog("URL")) {
   System.exit(0);
} else {
   System.exit(1);
}

To use a standard NetBeans Platform dialog, the sample above can be replaced with:

... // as above
DialogDescriptor dd = ValidationUtil.createDialogDescriptor(vp, panel, "URL");
Object ret = DialogDisplayer.getDefault().notify(dd);
if (DialogDescriptor.OK_OPTION.equals(ret)) {
   System.exit(0);
} else {
   System.exit(1);
}

public class ValidationUtil {

   private ValidationUtil() {
      // default constructor suppressed for non-instantiability
   }

   public static DialogDescriptor createDialogDescriptor(ValidationPanel vp, Object innerPane, String title) {
      final DialogDescriptor dd = new DialogDescriptor(innerPane, title);

      ValidationUI okButtonEnabler = new ValidationUI() {
         private NotificationLineSupport nls = dd.createNotificationLineSupport();

         public void showProblem(Problem problem) {
            if (problem != null) {
               switch (problem.severity()) {
                  case FATAL:
                     nls.setErrorMessage(problem.getMessage());
                     dd.setValid(false);
                     break;
                  case WARNING:
                     nls.setWarningMessage(problem.getMessage());
                     dd.setValid(true);
                     break;
                  default:
                     nls.setInformationMessage(problem.getMessage());
                     dd.setValid(true);
               }
            } else {
               nls.clearMessages();
               dd.setValid(true);
            }
         }

         public void clearProblem() {
            showProblem(null);
         }
      };

      vp.getValidationGroup().addUI(okButtonEnabler);
      vp.getValidationGroup().performValidation();
      return dd;
   }
}