Below is the workaround. The idea is to maintain the JMenuItem reference ourselves and set the appropriate (checked/enabled) state.
So you can inherit from WorkaroundBooleanStateAction instead of original BooleanStateAction

public abstract class WorkaroundBooleanStateAction extends BooleanStateAction {
    // if needed do you own stuff
 
    /* XXX Netbeans Platform bug 207477
     * Workaround for Mac OSX Bug with BooleanStateAction enabled and selected
     * so keep track JMenuItem ourselves
     */
    private WeakHashMap<JMenuItem, WeakReference<JMenuItem>> menuItemsMap 
            = new WeakHashMap<JMenuItem, WeakReference<JMenuItem>>();
 
    @Override
    public JMenuItem getMenuPresenter() {
        if (Utilities.isWindows()) {
            return super.getMenuPresenter();
        }
        JMenuItem menuItem = super.getMenuPresenter();
        menuItemsMap.put(menuItem,new WeakReference<JMenuItem>(menuItem));
        return menuItem;
    }
 
    @Override
    public void setBooleanState(boolean value) {
        super.setBooleanState(value);
        if (!Utilities.isWindows()) {
            for (JMenuItem menuItem : menuItemsMap.keySet()) {
                menuItem.setSelected(value);
            }
        }
    }
 
    @Override
    public void setEnabled(boolean value) {
        super.setEnabled(value);
        if (!Utilities.isWindows()) {
            for (JMenuItem menuItem : menuItemsMap.keySet()) {
                menuItem.setEnabled(value);
            }
        }
    }
 
    // if needed do you own stuff
}

note: above is a hack (workaround) without modifying any platform code. It is not proper solution

So how to fix that. The menu black things can be solved by changing the ambience theme into another theme or you can edit the ambience theme resources definition file. But the global menu and HUD integration is harder to workaround.

Luckily if you are using Netbeans you can just use Java Ayatana plugin which solve all the problem above. Java Ayatana will integrate Netbeans nicely with Ubuntu Unity eg: Ubuntu global menu, Ubuntu HUD integration, Unity launcher fix, etc.

How to install Java Ayatana Plugins
- In Netbeans, goto menu – Tools – Plugins
- On the settings tab, add the Update Center, and use
* Name: Java Ayatana
* URL: http://java-swing-ayatana.googlecode.com/files/netbeans-catalog.xml
- On the Available Plugins tab, choose reload, then find and install Java Ayatana
- Restart Netbeans and done. Netbeans is integrated with Ubuntu Unity

For detailed instructions please visit Java Ayatana plugins

And if by any case you are developing Netbeans Platform application, you also can use Java Ayatana plugins as extra cluster.

*see Ubuntu Unity global menu works

*see Ubuntu Unity HUD integration

It is because the default digest algorithm for Java 7 is SHA-256,
see http://docs.oracle.com/javase/7/docs/technotes/tools/windows/jarsigner.html

So one of the easiest way to sign android apk using jdk 7 is by adding the following to the build.xml

<presetdef name="signjar">
    <signjar sigalg="MD5withRSA" digestalg="SHA1" />
</presetdef>

note: the above example is using Netbeans 7.1.2 with NbAndroid plugins.
Other IDE should adjust accordingly.

1. You just need to download the latest NbAndroid plugins from NbAndroid
2. The Goto Menu – Tools – Options,
   on Miscellaneus – Android,
   and set your android sdk there.
3. You are done.

Now you are ready to develop Android App from Netbeans IDE

Java Swing Future

It is still not very clear yet, how Java Swing will evolve in the future as said in the blog above

The crux of the problem is that Swing is rooted in the antiquated AWT, rather than being integrated into the 2D coordinate system. Fixing this would require some massively incompatible changes and once you march down that path, well, you start asking yourself what other incompatible improvements should be made ….pretty soon the remodel becomes reconstruction and you realize that a new foundation is really needed.

But don’t get me wrong, it is not whether Swing will vanish or not, of course everything will be evolved. But, the focus is on the evolution of Swing and it is still unclear how Swing will evolve in the future. As you can see from the things that I quote above, “Swing is rooted in the antiquated AWT… and fixing this would require some massively incompatible changes …remodel becomes reconstruction …”

However, the good news is that whatever decision Oracle made to Swing evolution, “it’s still there and it isn’t going anywhere” as Amy said.

Java FX Future

On the other hand, Java FX get the most focus and attention for Java client side and have much more clear roadmap. In contrast to Swing, Java FX has more modern underlying structure (Prism + scene-graph + UI controls) plus a hardware-accelerated graphics pipeline with a UI rooted in a 2D/3D scene-graph can do. Imagine what you can do as Java developer for either business application or RIA media frenzy application like you saw on iPhone, etc with hundreds of rotating media cubes or jumbling block. It will gonna be interesting.

And from what I can understand from Amy’s blog. Currently, Oracle is converting JavaFX to a proper Java library and killing JavaFX script. So Java developers don’t have to learn a new language to use it. And the good news is “… Much of the JavaFX stack has already been ported off of script, so this is all quite real and the team is ecstatic to be doing Java again..” said Amy

Development Environment/Tools (Netbeans)

“A sleeper detail from Thomas Kurian’s keynote is that NetBeans will be the Java development IDE of choice going forward. This is very good news for Swing, ensuring it’s support and upkeep for a long time to come.”

And on the JavaFX front “we are working closely with that team to ensure JavaFX2.0 is toolable from the start.”

Summary

So my summary are
- Swing evolution is uncertain yet, but Swing is here to stay.
- JavaFX script is dead, but soon there will be JavaFX as Java library.
- Netbeans will provide tooling support for JavaFX

Sources:

• A Heartfelt Ramble on Swing & JavaFX
• JavaFX 2.0 at JavaOne 2010
• JavaFX 2010-2011 Roadmap

The chapters structure is nice and follow the logical step and easy to follow:

• Chapter 1, Module: the basic building block of Netbeans Platform Application.
• Chapter 2, Forms: You learn how forms are created for usage on the NetBeans Platform, how their layout is set, and how to implement the related handling of events.
• Chapter 3, Window System: The NetBeans Window System, together with the API that it exposes, lets you arrange forms on the screen within a docking framework.
• Chapter 4, Lookup: The Lookup API provides a communication mechanism, comparable to an event bus, which is of central significance in the creation of NetBeans Platform applications.
• Chapter 5, Actions: You learn how to create actions and how to invoke them from menus and toolbars, including keyboard shortcut and context sensitive action.
• Chapter 6, Nodes and Explorer Views: A sophisticated MVC implementation for displaying business objects is made available via a set of extensible Swing components, which you can use without very much work at all.
• Chapter 7, File System: The File System API lets you access a NetBeans Platform’s virtual filesystem, which serves as the application’s central registry and configuration system.
• Chapter 8, Data System: The Datasystems API gives you access to the content of files. You learn how to extend a NetBeans Platform application to provide support for custom data types.
• Chapter 9, Dialogs: The responsibilities of dialogs in an application extend from the display of simple messages to the management of step-by-step procedural wizards.
• Chapter 10, Settings: which introduces you to the most important APIs and the entry points into the centralized Options window.
• Chapter 11, Help: HTML files constituting your documentation can be integrated into the application which can be invoked using action or keyboard shortcut
• Chapter 12, Branding: which enables the application’s ancillary details, such as icons and splash screens, to be customized.
• Chapter 13, Distribution and Updates: To let you distribute applications, and examine the various distribution mechanisms for NetBeans Platform applications including installer and online update.

Important, the book’s author write

“This book doesn’t aim to explicate all that the NetBeans Platform offers or to explore each and every corner of its many features. Rather, this book guides you through the development of a specific Java desktop application, while showing you everything that is relevant in the context of the particular application itself. That process, in turn, will lead you through the main features relevant to the development of most general
applications on the NetBeans Platform.”

For me, this book is really good to introduce Netbeans Platform development. It discuss all or most important API in Netbeans Platform from basic module creation to deployment and how to integrate them all together. Another good thing is this book using single application sample (Task Management Application) through out all the chapters. So each chapter add more features to the application sample, rather than each chapter using different example to describe the Netbeans Platform API. However, this book is not without flaw. Chapter 2 (Forms) discuss too much about Swing Layout and Netbeans Form Builder which is not necessary (IMHO, this book is not about Swing and Netbeans IDE, but about Netbeans Platform). Other than that, the book is good introduction to Netbeans Platform development.

I have been developing Netbeans Platform Application since few years and release (public release) at least 3 applications based on Netbeans Platform, so I know my way around Netbeans Platform API. But this book still give me few surprises regarding Netbeans API, and my favorite is the Lookup API (Chapter 4). And yes you can teach old dog new trick

Link To the Book

• Netbeans Platform 6.9 Developer’s Guide
• Book Errata
• Another Review of this book by Tushar Joshi

Additional Link related to Netbeans Platform

• NetBeans Platform Teaching Resources

Step 1: Create ComponentOrientation support class

This step is optional, but make the testing easier, because it use the value component orientation from System.getProperty(“..”), and use auto (based on Locale.getDefault() if nothing specified.

    public class ComponentOrientationSupport {
 
        private ComponentOrientationSupport() {
            throw new Error("ComponentOrientationSupport is a utility class for static methods"); // NOI18N
        }   
 
        /** 
         * Return component orientation base on the value of
         * {@code System.getProperty("alkitab.orientation")} <br/>
         * If it is not specified it will return ComponentOrientation.LEFT_TO_RIGHT
         * Possible value are:
         * <code>
         * - auto (Default), automatic setting based on Locale.getDefault()
         * - ltr, force to use Left to Right orientation
         * - rtl, force to use Right to Left orientation
         * </code>
         * @return ComponentOrientation
         */
        public static ComponentOrientation getComponentOrientation() {
            ComponentOrientation orient = ComponentOrientation.getOrientation(Locale.getDefault());
 
            String str = System.getProperty("component.orientation");
 
            if (str != null) {
                if (str.equals("ltr")) {
                    orient = ComponentOrientation.LEFT_TO_RIGHT;
                } else if (str.equals("rtl")) {
                    orient = ComponentOrientation.RIGHT_TO_LEFT;
                }
            }
 
            return orient;
        }
 
        /** Apply the getComponentOrientation to the specified container
         * @param container Container
         */
        public static void applyComponentOrientation(Container container) {
            container.applyComponentOrientation(getComponentOrientation());
        }
    }

Step 2: Apply the component orientation for the MainWindow

In order to apply the component orientation to the MainWindow, you need to do that in the ModuleInstall eg:

    @Override
    public  void restored() {
        super.restored();
 
        // initialize the orientation
        String orientationKey = "component.orientation";
        String strOrientation = System.getProperty(orientationKey);
        if (strOrientation == null) {
            strOrientation = "auto";
        } else {
            strOrientation = strOrientation.trim().toLowerCase();
        }
        System.setProperty(orientationKey, strOrientation); // re-setting the System property to the correct value
 
        // do something else
        //....
 
        WindowManager.getDefault().invokeWhenUIReady(new Runnable() {
            public void run() {
                ComponentOrientationSupport.applyComponentOrientation(WindowManager.getDefault().getMainWindow());
 
                // do something else
                //....
            }
        });
    }

Step 3: Apply the component orientation for each TopComponent

You need to apply component orientation for each TopComponent you have eg:

    public final class MyTopComponent extends TopComponent {
        private MyTopComponent() {
            initComponents();
            setName(...);
            setToolTipText(...);
 
            // do something else
            //....
 
            ComponentOrientationSupport.applyComponentOrientation(this);
        }
    }

Step 4: Testing

Because it is using System.getProperty(“..”), so it is easy to test the UI. You only need to assign that component.orientation=auto|ltr|rtl to the environment. In Netbeans Platform based application you can do that in the suite project.properties by adding

run.args.extra=-J-Dcomponent.orientation=rtl ...your other things eg: -J-Xms64m -J-Xmx128m ...

Or for deploying you can use ../etc/yourapp.conf as above. Or if you are not setting it up, it will use “auto” by default which is based on Locale.getDefault()

There are a lot of them from various categories: Aerospace & Defence, Oil & Gas Services, Geospatial, Bio & Chemoinformatics, Scientific Modelers, Monitors, & Analyzers, Healthcare, Network Management & Communications Systems, Retail, Graphic Design & Image Manipulation, Music & Entertainment, Software Development.

So let’s me iterate again (or read this instead) why it is good idea to use RCP (Rich Client Platform) vs Java plus libraries. For me Rich Client Platform (RCP) is a set of libraries with tight integration, it was build from ground up to work together as a platform so other application can be build or run on top of it. In contrast, Java plus libraries is a mix and match of libraries to support the application eg: give new features, etc.

One main problem with the mix and match style is because that libraries may not be designed to work together, they could be excellent library on its own, but once they integrated together to form a single system (an application), sometimes it may require some glue or bridge code to make them work together. On the other hands for RCP, these set of libraries will work together since it is designed that way from beginning.

The module some.package.path is not a friend of some-path\some.jar

So what is friend dependency anyways. Friend Dependency is caused by a Module that have an API which its author is not yet comfortable exposing to just anyone, because it might not be fully stabilized yet. In this case, the module with the API can declare some public packages, but also stipulate that only a predefined list of “friend modules” are permitted to use them. The friend modules just declare a regular specification version dependency, but unknown modules are not permitted to use any packages from the API module.

So in order to declare a dependency to that module, you need to use an implementation dependency. Please read the following Netbeans Wiki Dev FAQ on how to declare this implementation dependency and to enable friend dependency.

note: please also understand that implementation dependencies cause special problems for Auto Update. It is explained on the Netbeans Wiki Dev FAQ as well

If you are wondering how do we track Java version, please visit this step by step guide on how to track java version using google analytics at
http://cowwoc.blogspot.com/2008/11/tracking-java-versions-using-google.html

Here is our Java visitor stats, it is fresh from Google Analytics data 05 December 2008 – 05 January 2009

and the corresponding Operating System (OS) stats

Based on the above, Java 1.6_xx seems to have very nice grounds, and the Java 1.5 (9.36%) seems come from Mac OSX (12.90%), not set is probably from visitor who disable javascript (noscript).

The only things that puzzle me is the Java 1.8.0 (6.59%). Where does it come from or is there really a Java 1.8.0 ? If you know where this 1.8.0 come from, please do not hesitate to drop me a note.