It provides pointers for Java rich client development by someone who spends part of his time as a Swing developer and is the creator of blueMarine, an open source application for digital photo workflows. Lots of interesting topics covered, including NetBeans Lookup class and the update functionality that your application can have too for free, as well as the standard NetBeans objects such as FileObjects, DataObjects, Nodes, Explorer Views, etc.
In Financial Applications on the NetBeans Platform I mentioned that Experian develops applications on the NetBeans Platform. (Their codebase consists of "over 100 NetBeans modules".) An interview done with them, about their work on the NetBeans Platform, some time ago, is being updated and should be ready for publication soon, now that permission has been received to publish it.
Here are two screenshots recently received from Experian, showing yet another NetBeans Platform application that doesn't look like an IDE at all, i.e., the NetBeans Platform is a generic framework for any kind of desktop application:
I especially like how the company-specific icons (within panels) have been integrated into the various components shown above.
In other news. Here's the interview referred to above: Enterprise Financial Management on the NetBeans Platform.
More pics here: http://picasaweb.google.com/JavaPolis.com/Devoxx2009
In other news. Watch a movie I made at the conference about interesting things learned at Devoxx: http://java.dzone.com/one-thing-from-devoxx.
Told you they were cryptic. But at least I know what it all means. Need to do the above before 6.8 so that the Wicket plugin can be released around the same time.
The NetBeans team gave a development group from IAV a NetBeans Platform Certified Training, in Prague, a few years ago. We contacted them about the progress of their work and today we got a very cool reply from them:
"Things are going very well so far! Our tool EasyDoE Toolsuite (PDF) has become a real big guy ;-). It provides a workflow for calibration engines (or, better, for its control unit) by using a method called Design of Experiments. The workflow guides the user through the whole process, starting at defining the task, making a test plan, importing data, making a mathematical model from the data, using the model in optimizations and calibrate maps that are directly exported to the engine control units."
They also sent some very cool screenshots (click to enlarge them):
Thanks to Berthold Barzantny and the rest of the IAV development team who created the above really professional looking application!
http://channelsun.sun.com/video/open-source/
Once you are there, click "NetBeans". If you click the small scrolling arrow below the thumbnails (look at the mouse pointer in the screenshot below) you can also get to the "Top 10 NetBeans APIs" screencast series.
Or, do it the easy way and simply go to the related page on netbeans.org, where the entire series is collected in one place:
http://platform.netbeans.org/tutorials/nbm-10-top-apis.html
Why? Because NetBeans went through a massive migration process during the past week, during which many obsolete projects have been removed from the site and a lot of restructuring of everything has taken place. The good news is that the whole site is now under the control of the NetBeans team, rather than a third party. The so-so news is that several things still need to be tweaked to get everything working correctly now that the migration itself has come to an end. For example, currently, it's not possible to log into the Plugin Portal yet, though that should change within the next few hours.
New passwords and other info has been sent around to mailing lists as well as individual subscribers.
The complete story with all its ramifications can be found here: http://wiki.netbeans.org/NewNBOrg
If you encounter any problems, please report them to:
https://netbeans.org/bugzilla/enter_bug.cgi?product=www&component=Admin
There'll be several loose ends in the next few days, so please be patient as things are being ironed out. And, remember, from now onwards, use dev@platform.netbeans.org (instead of dev@openide.netbeans.org).
I've added a few small additions to the sources (i.e., not in the binary yet):
First, there are new file templates specifically for Vaadin:
For example, simply by adding "SimpleAddressBook" (which adds one Java file to your source structure), you end up with an address book that includes a search feature in your web application:
Secondly, when you press Alt-Insert, you have a new code generator, named "Vaadin Button":
Press the "Vaadin Button" menu item and you have a new button, together with the implementing class added to the class signature, with a hint in the left sidebar for generating the abstract method that is invoked when the button is pushed:
Most importantly, now that these features have been added to the sources, someone else (e.g., from the Vaadin team) can take those sources and add MORE file templates and code generators to the plugin.
I didn't need to configure anything in NetBeans IDE at all. And, as always, my favorite feature of Griffon support in NetBeans IDE continues to be the fact that I can use "Open Project" and then simply open any Griffon project (i.e., without any kind of import procedure at all, simply open your Griffon project, since the Griffon plugin understands that the presence of a "griffon-app" folder indicates it is dealing with a Griffon application):
You then have a logical view for working with your Griffon applications, as well as menu items on top of the standard Griffon commands:
Best of all, no NetBeans metadata of any kind is added to your application. So, when you close NetBeans IDE you will have the same files as before you opened the project in the IDE. Nothing new is added, no small XML files or property files have been added to your project, or (even worse) proprietary files of any shape or form, either.
Plus, there are many other useful features, such as a dialog for browsing & installing plugins into your application:
Updated plugin for Griffon in NetBeans IDE 6.8 Beta is in the usual place:
http://plugins.netbeans.org/PluginPortal/faces/PluginDetailPage.jsp?pluginid=18664
ZIPs containing binary distributions of this and previous releases are available here on Kenai.
September 2009: Hermine Deurloo (harmonica) and Han Bennink (drums), with Ernst Glerum (bass) and Maarten van der Grinten (guitar).
How do I know that these organizations are using the NetBeans Platform? By looking in the dev@openide.netbeans.org mailing list:
However, getting screenshots, interviews, etc, out of financial organizations is understandably difficult, since (in the best case) long approval processes need to be completed, while in the worst case no information of any kind can be shared with the outside world, because of the confidential nature of the applications in question, in particular the confidential nature of the related customer data.
Nevertheless, in addition to the public statements around Brazilian financial auditing being done on the NetBeans Platform, there are a few smaller, more personal, applications relating to financing that could be mentioned in this context:
Are there other financial applications out there that make use of the NetBeans Platform? Please let me know!
Yesterday I received a set of screenshots from the abovementioned developers, showing their Exie Builder, which I discussed recently, to illustrate the result of the Microsoft Office look in the context of their NetBeans Platform application. Here they are, click to enlarge them.
Thanks Exie developers. Now there's more than 'just' blueMarine as proof that building applications on top of the NetBeans Platform doesn't mean that the result necessarily ends up resembling NetBeans IDE.
It comes from here, but that's all that I know about it:
http://p.blog.csdn.net/images/p_blog_csdn_net/chenweionline/366238/o_Tangram_build20080222_001.jpg
I believe it is a NetBeans Platform application... can anyone tell me whether I am right or not?
Here's a screenshot:
Reading the documents on the Exie site, it seems to me that Exie 2.0 is a pretty serious application, used amongst others by Norway's largest newspaper, VG: "With Exie we are able to change things quickly, and we could not have a rigid system. The service level Exie has shown is great."
However, on the face of it looking at the screenshot above, that doesn't really look like a NetBeans Platform application. However, firstly, it's architecture is clearly based on the NetBeans Platform:
A second reason why the NetBeans Platform is clearly being used at Exie is that two recent presentations at Jazoon were about some pretty advanced NetBeans Platform topics, both delivered by Exie employees:
Here's the intriguing abstract for the latter presentation:
Engineer tools like the familiar IDEs (Eclipse/IDEA/NetBeans etc.) have user interfaces increasingly different from office tools like Microsoft Office. When creating applications for end users it is important to aim for the look and feel this group is comfortable with rather than what would be intuitive for the engineer. At Exie AS we have developed an open source Swing look and feel component that dramatically simplifies this task.Just as it is important to utilize frameworks to improve productivity when developing web-based solution, so is the case with rich clients/desktop applications. A significant part of a desktop application consists of UI and IO plumbing. When should various menus, buttons and tool bars be enabled? Flexible docking frameworks, user preferences etc. There are various RCP frameworks available, however for a Swing based client the NetBeans RCP is perhaps the most complete.
How to create an NetBeans RCP client and make it look like a member of the Microsoft Office package? It is quite easy, and I am going to show you how.
And it would be great to get more screenshots, also one for the NetBeans Platform Showcase of this clearly very interesting application!
Click to enlarge the (very cool!) pics:
I found the pics above in Rich Unger's blog, although he doesn't know anything about it either:
http://weblogs.java.net/blog/richunger/archive/guada1.png/guada1.png
Can anyone let me know what this apparently very cool application is for, what it does, and who is behind it?
You can save yourself that trouble, by excluding the "java.awt" and "java.text" packages (which you're not using with Wicket anyway) in the "Editor" section of the Options window (under the Tools menu):
With those packages excluded, the first class that appears in code completion is the one you want for your Wicket applications:
Then just press OK and you have all the imports from Wicket and you're ready to continue coding right away.
Here's a screenshot:
O3MiSCID can be really helpful in the following areas:
O3MiSCID is born in the PRIMA project from INRIA Rhône-Alpes.
For further information, go here.
The program calculates heating and refrigeration demands in different ways, while taking account of factors such as shade, enclosure characteristics, and solar gains. The designer estimates how to distribute the different elements in the best way in order to reduce energy consumption.
The application is being developed by GEE (Grupo de energía y edificiación) at the Universidad de Zaragoza in Spain.
The netbeans.org site is going to be migrated into kenai.com infrastructure during next week
The above is info that is publicly available at kitt.co.za.
Like what Northrop Grumman, Boeing, ND SatCom, and many others provide, SSG has a centralized platform, called KORE, where the NetBeans Platform plays a central role. On top of KORE, various applications are created.
Here are the two current products:
The TGIS can be used in the following environments:
Now have a look at the future projects and read about the various new features and applications that are being planned.
Then, today, literally within the space of a half hour, Sven Reimers and Nicolas Dumoulin, both of whom work on YANPA's themselves, sent me e-mails (i.e., separately, unbeknown to each other, from different countries) about YANPA's they've recently come across.
So, in order of appearance in my inbox a few hours ago:
Here's one of several screenshots available on the related site:
Now, read here about NetBeans Platform on the Gephi site. In his e-mail to me, Nicolas adds: "It's NetBeans Platform based, and it rocks!"
Here are the screenshots that Sven referred me to:
Pretty cool, need to add them to the NetBeans Platform Showcase soon, which currently has 99 screenshots, over 20 more waiting to be added, and several more in the pipeline from companies that have been requested to show off their cool work on the NetBeans Platform!
And now look at the explorer view in the RIGHT of this pic:
The same module installed twice. But... look at "Add System Property" in the left of the top window and then compare that to "Add" (which is greyed out and inactive) in the right of the second window. Those are the SAME menu items.
Why is getNewTypes rendered DIFFERENTLY when it is in the Services (a.k.a. Runtime) window compared to when it is rendered in my own custom explorer view?
And I am not alone with this question:
Solution: Hook the explorer manager of your own component to the component's action map and then add that to the context of your component:
Lookup lkp = ExplorerUtils.createLookup(em, getActionMap()); associateLookup(lkp);
Do the above in the constructor of the TopComponent. Now run the module again and when the node appears in your own component, its actions will behave correctly.
When I click the button, an action that is registered in the layer is invoked. That's great, means that I can integrate my standard Swing components with the NetBeans System FileSystem. Plus that lets me empower the action declaratively with, for example, asynchronous processing by adding a single attribute to the related layer entry (see elsewhere in this blog for this 6.8 enhancement).
How is all this possible?
Well, this is how the action is registered in the layer:
<folder name="Actions">
<folder name="Bla">
<file name="org-demo-globloc-GlobLocAction.instance">
<attr name="delegate" newvalue="org.demo.globloc.GlobLocAction"/>
<attr name="displayName" bundlevalue="org.demo.globloc.Bundle#CTL_GlobLocAction"/>
<attr name="instanceCreate" methodvalue="org.openide.awt.Actions.alwaysEnabled"/>
<attr name="noIconInMenu" boolvalue="false"/>
</file>
</folder>
</folder>
<folder name="Menu">
<folder name="File">
<file name="org-demo-globloc-GlobLocAction.shadow">
<attr name="originalFile" stringvalue="Actions/Bla/org-demo-globloc-GlobLocAction.instance"/>
<attr name="position" intvalue="0"/>
</file>
</folder>
</folder>
Take note of the bits in bold above. Now, this is in the button's action performed:
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
ActionListener al = Lookups.forPath("/Actions/Bla/").lookup(ActionListener.class);
al.actionPerformed(evt);
}
Here the scenario is very simple, since we know exactly where the action listener is registered and that there is only one file registered in the folder.
More complex scenarios, where you have separators as well as other actions registered in the same folder, require you to do some testing of the instances. See Layer-Based Popup Menus in TopComponents and the other references you find there for further details, if needed.
Also see this discussion from today, which includes code from Fabrizio.
In other news. What's the deal with OSGi and the NetBeans Platform? Watch this brand new screencast for all the details.
And so I integrated it today and here's how the Video Store sample now looks:
The checkboxes work as you'd expect—check a checkbox and then the movie is added to the list on the right; uncheck a checkbox and then the movie is removed from the list on the right.
This is where the whole sample can be found:
http://kenai.com/projects/nbvideostore
And here's the source structure:
Next steps are to add selection handling, i.e., when a movie is selected in the left window, the corresponding movie on the right should be selected and vice versa. Then, after that, split the application into three modules, one for each window, sharing a third module that provides the domain objects.
Hope it helps, Markus.
In other news. For an example of the extreme vibrancy of the NetBeans Platform community, read this brand new interview with Peter Rogge, hero of every multilingual NetBeans Platform developer.
http://kenai.com/projects/nbfiltersample
The scenario is where you have a list in one explorer view and you'd like to use checkboxes to add/remove selected items from that explorer view to/from another explorer view in a different TopComponent:
I spent most of the time trying to use FilterNode.Children, but that's probably not even the purpose of that class. I was trying to use it because I wanted one explorer view to provide a FilterNode on top of a Node from a different explorer view. It didn't work because both views ended up with the same nodes, i.e., the CreateNodes in the FilterNode.Children didn't enable me to create different nodes for the different views. Ultimately I gave up on that approach and simply added/removed items to/from a list that the second children object used to create new nodes in the lower window.
This is how the source structure looks. You can see the two sets of classes for the windows selected. The other classes are "Movie" (which is the domain object), "RootNode" (which includes an action for adding new items to the top window), "CheckNode" (which implements CheckableNode and is added to the Lookup of the node in the top window), and "Utils" (which provides the lists and ChangeSupport that is shared between the other classes).
So not, as intended, a sample of FilterNode.Children. But still very useful, I believe.
It's time for celebration. The NetBeans team released the Beta of NetBeans 6.8 finally. The plan was to publish it yesterday but sometimes you cannot make it. Reason? Slow upload. Could you imagine how many GB have to be uploaded? This could be great quiz question for Geertjan's NB podcast 
OK. No one ever said that. Nevertheless, since it's Friday, the YANPA of the day needs to be slightly off the wall, so here it is...
Yes. That, my friends, is what a rat brain analyzer (apparently) looks like. It is built on the NetBeans Platform (from several releases ago).
"The Virtual RatBrain Project formed in 2004 in order to build a repository of peer reviewed 3-D cellular anatomical data of the rat brain, collected at multiple levels and from multiple brain regions, including point-to-point coordinate connections, cell populations of different neurochemical phenotype and dendritic and axonal arborizational patterns." Read all about it here, on the slightly squeamishly named http://www.virtualratbrain.org/.
Software architecture:
A number of different people have been involved in this project, from institutions like the Center for Molecular and Behavioral Neuroscience and the Institute of Adaptive and Neural Computation. So... that's yet another bioinformatics application on the NetBeans Platform!
And guess what? They used the NetBeans Platform: "For the GUI we chose the NetBeans Platform. NetBeans provides us with a plug and play IDE with services common to almost all desktop applications – windows, menus, settings management and storage, file access and more."
Screenshots:
Though the work seems to have been done in and around 2004, the website makes for an interesting read.
Prague Team
