So here how to do it in JavaFX WebView
* tested on Java 7u25

public class WebViewRenderer extends JFXPanel
    public static final String EVENT_TYPE_CLICK = "click";
    public static final String EVENT_TYPE_MOUSEOVER = "mouseover";
    public static final String EVENT_TYPE_MOUSEOUT = "mouseclick";

    protected WebView webView;
    
    public WebViewRenderer() {
        ...
        Platform.runLater(new Runnable() {
            @Override
            public void run() {
                initFX();
            }
        });
    }
    
    private void initFX() {
        createScene();
        
        webView.getEngine().getLoadWorker().stateProperty().addListener(new ChangeListener() {
            @Override
            public void changed(ObservableValue ov, State oldState, State newState) {
                if (newState == Worker.State.SUCCEEDED) {
                    EventListener listener = new EventListener() {
                        @Override
                        public void handleEvent(Event ev) {
                            String domEventType = ev.getType();
                            //System.err.println("EventType: " + domEventType);
                            if (domEventType.equals(EVENT_TYPE_CLICK)) {
                                String href = ((Element)ev.getTarget()).getAttribute("href");
                                ////////////////////// 
                                // here do what you want with that clicked event 
                                // and the content of href 
                                //////////////////////                               
                            } 
                        }
                    };

                    Document doc = webView.getEngine().getDocument();
                    NodeList nodeList = doc.getElementsByTagName("a");
                    for (int i = 0; i < nodeList.getLength(); i++) {
                        ((EventTarget) nodeList.item(i)).addEventListener(EVENT_TYPE_CLICK, listener, false);
                        //((EventTarget) nodeList.item(i)).addEventListener(EVENT_TYPE_MOUSEOVER, listener, false);
                        //((EventTarget) nodeList.item(i)).addEventListener(EVENT_TYPE_MOUSEOVER, listener, false);
                    }
                }
            }
        });
    }
}

Thats it done. Now you can handle the hyperlink click event.

But if you really want to replicate addHyperlinkListener as in JTextPane just add the following

    @Override
    public void addHyperlinkListener(HyperlinkListener listener) {
        listenerList.add(HyperlinkListener.class, listener);
    }
    
    @Override
    public void removeHyperlinkListener(HyperlinkListener listener) {
        listenerList.remove(HyperlinkListener.class, listener);
    }
    
    protected void fireHyperlinkUpdate(EventType eventType, String desc) {
        HyperlinkEvent event = new HyperlinkEvent(this, eventType, null, desc);
        
        // Guaranteed to return a non-null array
        Object[] listeners = listenerList.getListenerList();
        // Process the listeners last to first, notifying
        // those that are interested in this event
        for (int i = listeners.length - 2; i >= 0; i -= 2) {
            if (listeners[i] == HyperlinkListener.class) {
                ((HyperlinkListener) listeners[i + 1]).hyperlinkUpdate(event);
            }
        }
    }

And replace the above initFX with

    protected void initFX() {
        createScene();
        
        webView.getEngine().getLoadWorker().stateProperty().addListener(new ChangeListener() {
            @Override
            public void changed(ObservableValue ov, State oldState, State newState) {
                if (newState == Worker.State.SUCCEEDED) {
                    EventListener listener = new EventListener() {
                        @Override
                        public void handleEvent(Event ev) {
                            String domEventType = ev.getType();
                            //System.err.println("EventType: " + domEventType);
                            final EventType eventType;
                            if (domEventType.equals(EVENT_TYPE_CLICK)) {
                                eventType = HyperlinkEvent.EventType.ACTIVATED;
                            } else if (domEventType.equals(EVENT_TYPE_MOUSEOVER)) {
                                eventType = HyperlinkEvent.EventType.ENTERED;
                            } else if (domEventType.equals(EVENT_TYPE_MOUSEOUT)) {
                                eventType = HyperlinkEvent.EventType.EXITED;
                            } else {
                                return;
                            }
                            
                            final String href = ((Element)ev.getTarget()).getAttribute("href");
                            if (href == null) { return; }
                            SwingUtilities.invokeLater(new Runnable() {
                                @Override
                                public void run() {
                                    fireHyperlinkUpdate(eventType, href);
                                }
                            });
                        }
                    };

                    Document doc = webView.getEngine().getDocument();
                    NodeList nodeList = doc.getElementsByTagName("a");
                    for (int i = 0; i < nodeList.getLength(); i++) {
                        ((EventTarget) nodeList.item(i)).addEventListener(EVENT_TYPE_CLICK, listener, false);
                        ((EventTarget) nodeList.item(i)).addEventListener(EVENT_TYPE_MOUSEOVER, listener, false);
                        ((EventTarget) nodeList.item(i)).addEventListener(EVENT_TYPE_MOUSEOVER, listener, false);
                    }
                }
            }
        });
    }

So now you can easily use something like

WebViewRenderer renderer = new WebViewRenderer();
renderer.addHyperlinkListener(new HyperlinkListener() {
    @Override
    public void hyperlinkUpdate(HyperlinkEvent evt) {
        EventType eventType = evt.getEventType();
        String href = evt.getDescription();
        if (eventType.equals(HyperlinkEvent.EventType.ACTIVATED)) {
            // do something
        } else if (eventType.equals(HyperlinkEvent.EventType.ENTERED)) {
            // do something    
        } else if (eventType.equals(HyperlinkEvent.EventType.EXITED)) {
            // do something
        }
    }
});

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> menuItemsMap 
            = new WeakHashMap>();
    
    @Override
    public JMenuItem getMenuPresenter() {
        if (Utilities.isWindows()) {
            return super.getMenuPresenter();
        }
        JMenuItem menuItem = super.getMenuPresenter();
        menuItemsMap.put(menuItem,new WeakReference(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

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

Packt launch 5th annual Open Source Awards

Birmingham, UK. 9th August 2010

The 2010 Open Source Awards was launched today by Packt, inviting people to visit www.PacktPub.com and submit nominations for their favorite Open Source project. Now in its fifth year, the Award has been adapted from the established Open Source CMS Award with the wider aim of encouraging, supporting, recognizing and rewarding all Open Source projects.

WordPress won the 2009 Open Source Content Management System (CMS) Award in what was a very close contest with MODx and SilverStripe. While MODx was the first runner up, SilverStripe, a Most Promising CMS Award winner in 2008, made its way to the second runner up position in its first year in the Open Source CMS Award final.

The 2010 Award will feature a prize fund of $24,000 with several new categories introduced. While the Open Source CMS Award category will continue to recognize the best content management system, Packt is introducing categories for the Most Promising Open Source Project, Open Source E-Commerce Applications, Open Source JavaScript Libraries and Open Source Graphics Software. CMSes that won the Overall CMS Award in previous years will continue to compete against one another in the Hall of Fame CMS category.

These new categories will ensure that the Open Source Awards is the ultimate platform to recognise excellence within the community while supporting projects both new and old. “We believe that the adaption of the Award and the new categories will provide a new level of accessibility, with the Award recognizing a wider range of Open Source projects; both previous winners while at the same time, encouraging new projects” said Julian Copes, organizer of this year’s Awards.

Packt has opened up nominations for people to submit their favorite Open Source projects for each category at www.PacktPub.com/open-source-awards-home. The top five in each category will go through to the final, which begins in the last week of September. For more information on the categories, please visit Packt’s website www.PacktPub.com/blog/packt’s-2010-open-source-awards-announcement

http://blogs.msdn.com/ie/archive/2010/03/16/html5-hardware-accelerated-first-ie9-platform-preview-available-for-developers.aspx

This is great news for SVG designers or developers, because soon all major browsers will or already support SVG. Some already support SVG (Firefox, Google Chrome, Opera) and Microsoft Internet Explorer will follow the suit.

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")} 

         * If it is not specified it will return ComponentOrientation.LEFT_TO_RIGHT
         * Possible value are:
         * 
         * - auto (Default), automatic setting based on Locale.getDefault()
         * - ltr, force to use Left to Right orientation
         * - rtl, force to use Right to Left orientation
         * 
         * @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()