Thursday July 30, 2009
Thursday July 30, 2009
How to Navigate to VisualVM Sources
The question of the day is from Jeroen Borgers, who wants to navigate (Ctrl-Click on class/method names) to the VisualVM sources while creating VisualVM plugins in NetBeans IDE. Not only can you do that, but you can also read Javadoc:
Below follows an explanation of how to set up NetBeans IDE for this purpose.
When you check out the VisualVM sources from dev.java.net, you will end up with the folder structure below. The folder that you see highlighted, named "visualvm", contains the VisualVM sources:
In Tools | NetBeans Platform, where you've registered VisualVM as the platform against which your VisualVM modules will be compiled, you need to register the folder above, in the "Sources" tab and also in the "Javadoc" tab:
That's all. Then the sources and Javadoc are accessible from the Java editor in NetBeans IDE.
Jul 30 2009, 08:51:38 AM PDT Permalink
Add a Comment
Tuesday July 28, 2009
Griffon Alpha Plugin for NetBeans IDE 6.7
I created an Alpha version of the Griffon plugin for NetBeans IDE 6.7. The previous version was Pre-Alpha, created for little other reason than to allow Dierk, Danno, and others to demo Griffon apps in an IDE during their JavaOne 2009 presentations.
The biggest problem in that version was that the Griffon plugin destroyed the Grails plugin, which is now no longer the case. Also some user requests have been implemented, e.g., the 'src' folder is now also shown in the Projects window.
The binaries are here:
http://plugins.netbeans.org/PluginPortal/faces/PluginDetailPage.jsp?pluginid=18664
Please make sure to read everything on the page above before commenting or asking questions. For example, do NOT try to import Griffon applications (or Grails applications), simply OPEN them (because convention over configuration rocks for tooling support).
The whole thing is now open sourced too:
http://kenai.com/projects/nbgriffonsuite
Some screenshots, the first showing both Grails and Griffon apps in the IDE (note the 'Source Packages' folder, which is new in the Projects window, i.e., that's the 'src' folder in the Griffon app)...
...the second shows a list of project commands available to Griffon apps:
There are also file templates for Griffon artifacts, including the MVC structures.
Tomorrow I intend to make a screencast that goes over all the features of the Griffon plugin, which will then be published on netbeans.tv.
Jul 28 2009, 01:51:11 PM PDT Permalink
Monday July 27, 2009
Lexing & Parsing on the NetBeans Platform
I went through the New Language Support Tutorial for the first time today. It uses javaCC to create an editor (syntax coloring and syntax checking) for a simple language using the new Parsing API. The result is this:
As I went through the tutorial, I tweaked some things slightly and added a few screenshots. Now most of it should be clearer than before. (I also included a link to the completed 'SJLanguageHierarchy.java' file, which should save a bit of time.)
Interestingly, members of the NetBeans Platform community have been creating an ANTLR version of the same tutorial, covering syntax coloring, syntax error checking, indentation, and formating. Not bad going, Jeff Johnston! Go here to see the index page of that set of tutorials:
http://wiki.netbeans.org/Netbeans_Rcp_Antlr_Integration_Index
On a related note, take a look at Thibaut Colar's FAN language support module (in progress here) and Pawel Boguszewski's recently released OCaml plugin, now available on Kenai. I don't think Pawel's plugin uses the new Parsing API, but I think Thibaut's one might be doing so, especially since he told me he found Caoyuan's Erlang plugin sources very useful.
There are several NetBeans Platform developers on the dev mailing list working on language support, including Andreas Stefik, Tomas Lazaro, Jason Cech, James Read, Ernie Rael, and the aforementioned Jeff Johnston. So, the mailing list is definitely the place you want to be for cutting edge info on language support on the NetBeans Platform.
I've added the start of a new section to the NetBeans Developer Wiki on parsing on the NetBeans Platform, which currently has two entries, one for javaCC and one for ANTLR.
Jul 27 2009, 10:47:15 AM PDT Permalink
Sunday July 26, 2009
The Deprecation of CallbackSystemAction
In the past, you'd integrate your own action into the NetBeans Platform's CutAction like this, i.e., by using a TopComponent's ActionMap:
final ActionMap actionMap = instance.getActionMap();
CallbackSystemAction callCutAction = (CallbackSystemAction) SystemAction.get(CutAction.class);
actionMap.put(callCutAction.getActionMapKey(), new AbstractAction() {
@Override
public void actionPerformed(ActionEvent ae) {
NotifyDescriptor.Message msg = new NotifyDescriptor.Message("Cut cut cut...");
DialogDisplayer.getDefault().notify(msg);
}
});
Post 6.7, CallbackSystemAction will start moving to a black hole in space. Wherever you're using "CallbackSystemAction", you'll not be using it in future. In the case of the above, you'll simply type the string that defines the key of the action. In the case of CutAction, the related key is "cut-to-clipboard". Hence, I can comment out the "CallbackSystemAction" definition below and replace it in the action map with "cut-to-clipboard":
final ActionMap actionMap = instance.getActionMap();
//CallbackSystemAction callCutAction = (CallbackSystemAction) SystemAction.get(CutAction.class);
actionMap.put("cut-to-clipboard", new AbstractAction() {
@Override
public void actionPerformed(ActionEvent ae) {
NotifyDescriptor.Message msg = new NotifyDescriptor.Message("Cut cut cut...");
DialogDisplayer.getDefault().notify(msg);
}
});
The above implies that there needs to be documentation listing all the keys for all the existing actions in the NetBeans Platform. That list of keys should probably be in the upcoming NetBeans Platform DZone Refcard.
Now, let's say you have defined the original action yourself. That's different to the above original action, i.e., the CutAction, which is defined by the NetBeans Platform. So, in the case where you yourself, i.e., in your own custom module, have defined the action, you'd declare a menu item like this, as always:
<folder name="Menu">
<folder name="Window">
<file name="SomeAction.shadow">
<attr name="originalFile" stringvalue="Actions/Window/org-demo-bla4-SomeAction.instance"/>
</file>
</folder>
</folder>
So, you can see above that there's a reference to the original file in the "Actions" folder. In this case, i.e., where you'd like other actions to determine what happens when the menu item is clicked (hence, you're wanting other modules to provide a callback), you'd register the action above as follows:
<folder name="Actions">
<folder name="Window">
<file name="org-demo-bla4-SomeAction.instance">
<attr name="instanceCreate" methodvalue="org.openide.awt.Actions.callback"/>
<attr name="key" stringvalue="bla"/>
<attr name="surviveFocusChange" boolvalue="false"/> // defaults to false
<attr name="displayName" bundlevalue="org.demo.bla4.Bundle#CTL_Bla4Action"/>
<attr name="noIconInMenu" boolvalue="false"/>
</file>
</folder>
</folder>
Notice that we have defined our key as "bla" and our "instanceCreate" as org.openide.awt.Actions.callback. That means that anyone who wants to callback to the above action (i.e., implement their own Bla action, in the same way as implementing their own Cut action above), would do so like this, taking note of the line in bold:
final ActionMap actionMap = instance.getActionMap();
actionMap.put("bla", new AbstractAction() {
@Override
public void actionPerformed(ActionEvent ae) {
NotifyDescriptor.Message msg = new NotifyDescriptor.Message("Bla bla bla...");
DialogDisplayer.getDefault().notify(msg);
}
});
Therefore, note that we're not using CallbackSystemAction at all anymore, in post 6.7 builds. Also note that the original action is registered in the layer as a callback action. Unfortunately the NetBeans IDE XML editor sucks, since you're not able to use code completion to see the possible values to fill in for all those attributes. That's why I mentioned above that all these values need to be listed in a refcard. (And that the XML editor needs to be improved.) (And that the New Action wizard needs to let you register these kinds of actions into the layer file.)
One other thing is that we're moving more things into the layer XML file, which is good in that it makes the way you're using callbacks similar to how you're using any other kind of action. However, that's less good in that I was hoping we were moving away from the layer XML file. So I'm hoping this consolidation is a first step towards reimplementing all of this as annotations.
Further reading:
http://bits.netbeans.org/dev/javadoc/org-openide-awt/org/openide/awt/Actions.html#callback
Jul 26 2009, 03:42:04 AM PDT Permalink
Friday July 24, 2009
The Continuing March of ActionListener in the NetBeans Platform
One of the interesting enhancements to the NetBeans Platform in NetBeans Platform 6.5 was the fact that you can now use the standard JDK ActionListener class when creating 'aways enabled' menu items and toolbar buttons in your NetBeans Platform applications.
In the next release of the NetBeans Platform, i.e., after 6.7, this will go a step further. When you create 'conditionally enabled' actions, such as those that appear in the Java editor's contextual menu, you will be able to define your action like this:
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import org.openide.cookies.EditorCookie;
public final class BSomeAction implements ActionListener {
private final EditorCookie context;
public BSomeAction(EditorCookie context) {
this.context = context;
}
public void actionPerformed(ActionEvent ev) {
// TODO use context
}
}
So, again, you're using a plain old ActionListener, with the context that you're working with (the editor) being the only foreign class in your code.
Assuming you want the action to be invoked from a menu item on a node in the explorer view, the layer entries for the above would be as follows:
<folder name="Actions">
<folder name="Build">
<file name="org-demo-bla2-BSomeAction.instance">
<attr name="delegate" methodvalue="org.openide.awt.Actions.inject"/>
<attr name="displayName" bundlevalue="org.demo.bla2.Bundle#CTL_BSomeAction"/>
<attr name="injectable" stringvalue="org.demo.bla2.BSomeAction"/>
<attr name="instanceCreate" methodvalue="org.openide.awt.Actions.context"/>
<attr name="noIconInMenu" boolvalue="false"/>
<attr name="selectionType" stringvalue="EXACTLY_ONE"/>
<attr name="type" stringvalue="org.openide.cookies.EditorCookie"/>
</file>
</folder>
</folder>
<folder name="Loaders">
<folder name="text">
<folder name="x-java">
<folder name="Actions">
<file name="org-demo-bla2-BSomeAction.shadow">
<attr name="originalFile" stringvalue="Actions/Build/org-demo-bla2-BSomeAction.instance"/>
<attr name="position" intvalue="0"/>
</file>
</folder>
</folder>
</folder>
</folder>
If, on the other hand, the action class were to appear within the editor itself, the layer registration would be as follows:
<folder name="Actions">
<folder name="Build">
<file name="org-demo-bla3-BSomeAction.instance">
<attr name="delegate" methodvalue="org.openide.awt.Actions.inject"/>
<attr name="displayName" bundlevalue="org.demo.bla3.Bundle#CTL_BSomeAction"/>
<attr name="injectable" stringvalue="org.demo.bla3.BSomeAction"/>
<attr name="instanceCreate" methodvalue="org.openide.awt.Actions.context"/>
<attr name="noIconInMenu" boolvalue="false"/>
<attr name="selectionType" stringvalue="EXACTLY_ONE"/>
<attr name="type" stringvalue="org.openide.cookies.EditorCookie"/>
</file>
</folder>
</folder>
<folder name="Editors">
<folder name="text">
<folder name="x-java">
<folder name="Popup">
<file name="org-demo-bla3-BSomeAction.shadow">
<attr name="originalFile" stringvalue="Actions/Build/org-demo-bla3-BSomeAction.instance"/>
<attr name="position" intvalue="400"/>
</file>
</folder>
</folder>
</folder>
</folder>
The above is already possible with dev builds. Nevertheless, I'm looking forward to being able to do the above via annotations instead of layer entries.
Further reading:
http://bits.netbeans.org/dev/javadoc/org-openide-awt/apichanges.html#Actions.context
Jul 24 2009, 05:06:08 AM PDT Permalink
Thursday July 23, 2009
Stack Trace Hyperlink in Kenai Chat
Back from vacation, trying to catch up on everything, and found out about hyperlink support for stack traces in Kenai chat. Fetched all changes to my hg clone and rebuilt the IDE, with the following result, i.e., clicking a stack trace hyperlink in Kenai chat opens the related line in the editor:
Pretty cool!
Jul 23 2009, 09:56:27 AM PDT Permalink
Tuesday July 14, 2009
Wicket Support for Maven Projects in NetBeans IDE
Milos Kleint contributed some patches to http://nbwicketsupport.dev.java.net that will make it easier to integrate Wicket support in Maven web artifacts in NetBeans IDE. There's still one or two small problems with it, but here's a preview—you will be able to create everything you see below via 2 wizards (plus the Wicket filter is registered automatically in web.xml):
I was looking at the graph you see above and I noticed that reddish color. Didn't seem very healthy. So I right-clicked on that square and saw this:
OK, so I have a dependency problem. Let's see what happens when I click that menu item. Hey, I see this:
Fine. I'll let NetBeans IDE resolve the problem for me, so I simply clicked OK. And then the graph showed there were no problems, because everything was white as snow:
Pretty handy!
Jul 14 2009, 04:41:30 AM PDT Permalink
Monday July 13, 2009
The Divorce of SaveCookies from Nodes
I am happy to announce the permanent separation between Nodes and SaveCookies. If you're not happy with this announcement, then you're unlikely to benefit much from this blog entry. :-) (But here is a tiny bit of background.)
Using a build from sometime after the beginning of this month (or just update your trunk), I was able to do this:
...
...
...
private InstanceContent content;
private SaveCookieImpl impl;
public DemoTopComponent() {
initComponents();
setName(NbBundle.getMessage(DemoTopComponent.class, "CTL_DemoTopComponent"));
setToolTipText(NbBundle.getMessage(DemoTopComponent.class, "HINT_DemoTopComponent"));
//JTextArea fires changes when the document changes:
jTextArea1.getDocument().addDocumentListener(new DocumentListener() {
public void insertUpdate(DocumentEvent arg0) {
fire(true);
}
public void removeUpdate(DocumentEvent arg0) {
fire(true);
}
public void changedUpdate(DocumentEvent arg0) {
fire(true);
}
});
//Create a new instance of our SaveCookie implementation:
impl = new SaveCookieImpl();
//Create a new instance of our dynamic object:
content = new InstanceContent();
//Add the dynamic object to the TopComponent Lookup:
associateLookup(new AbstractLookup(content));
}
private class SaveCookieImpl implements SaveCookie {
@Override
public void save() throws IOException {
NotifyDescriptor.Message message = new NotifyDescriptor.Message("Do you really want to save?");
Object result = DialogDisplayer.getDefault().notify(message);
//When user clicks "Yes", indicating they really want to save,
//we need to disable the Save action,
//so that it will only be usable when the next change is made
//to the JTextArea:
if (NotifyDescriptor.YES_OPTION.equals(result)) {
fire(false);
//Implement your save functionality here.
}
}
}
public void fire(boolean modified) {
if (modified) {
//If the text is modified,
//we add SaveCookie impl to Lookup:
content.add(impl);
} else {
//Otherwise, we remove the SaveCookie impl from the lookup:
content.remove(impl);
}
}
...
...
...
Notice that there is no Node at all above. I'm simply using the standard pattern with InstanceContent to add/remove the SaveCookie to/from the InstanceContent upon changes to the document. Hurray!
Update 23 July 2009. How to add the Save button:
<folder name="Toolbars">
<folder name="File">
<file name="org-openide-actions-SaveAction.shadow">
<attr name="originalFile" stringvalue="Actions/System/org-openide-actions-SaveAction.instance"/>
<attr name="position" intvalue="444"/>
</file>
</folder>
</folder>Jul 13 2009, 11:24:25 AM PDT Permalink
Sunday July 12, 2009
Two Brand New NetBeans Platform Tutorials
I've made a (brave) attempt to consolidate everything I know about creating projects for NetBeans Platform applications into two tutorials:
Since the new annotations are used in these tutorials, you must use NetBeans Platform 6.7 if you want to create projects via these tutorials. (Using the 'old' way is not much different, though. Replace the annotations by appropriate META-INF/services and/or layer entries.)
There could be mistakes still, at this point. Typos or otherwise. Feel free to tell me so. Feedback of any kind is welcome, as always.
Jul 12 2009, 11:08:00 AM PDT Permalink
Saturday July 11, 2009
NetBeans Platform Student Provides OCaml Support in NetBeans IDE
My inbox is literally stuffed with news from developers working with the NetBeans Platform. Not one of them writes to say 'Hey, I have a cool Struts application created in NetBeans IDE.' Each and every one of them, without exception, writes to say 'Hey, I'm working on a cool NetBeans module to extend NetBeans IDE' or 'Hey, I'm working on a cool application on top of the NetBeans Platform.'
In fact, it is pretty obvious that the NetBeans Platform is a lot more inspiring than NetBeans IDE. That's because NetBeans IDE is a tool, while the NetBeans Platform is a framework. The latter is much more interesting, allowing for far more creativity, than the former. One indicator supporting this point is that several external users (i.e., outside of Sun Microsystems) have written books about the NetBeans Platform, without having been prompted or paid to do so... while none have done so for NetBeans IDE. Ask yourself—is it more interesting to write about a pen (which is a tool) or about poetry (which is a framework for expressing your feelings and thoughts)?
Here's one example. Pawel Boguszweski, one of the students from one of the Certified NetBeans Platform Trainings in Warsaw, who created the first NetBeans editor for Ruby for his Masters thesis (as reported here) is now working on OCaml support for NetBeans IDE. His OCaml support plugs into the NetBeans Platform which, when the modules that make up the rest of NetBeans IDE are plugged into it, together forms the tool that is NetBeans IDE.
He sent me the sources of his Beta release:
I ran it without much problems in NetBeans IDE 6.7:
Even some code completion is included:
The list of features Pawel lists in his e-mail:
- ocaml file support
- syntax highlighting
- code completion (keywords)
- build-in documentation
- ocaml projects support
- support for multiple source, test and docs folders
- support for multiple build systems
- support for custom build system
- sample project template
- empty project wizard
The next steps are to finish the build system, to finish the project logical view (properties window etc.) and then focus on the editor (contextual code completion, code folding, errors highlighting, code formating).
It would be cool to see the sources of this plugin uploaded to Kenai.com so that others can contribute to this plugin too!
Jul 11 2009, 04:43:48 AM PDT Permalink
Friday July 10, 2009
More Books Translations Coming From the NetBeans Platform Community!
The book recently released by Apress, entitled 'The Definitive Guide to NetBeans Platform' was a community translation. What that means is that the original book was written in German (by someone from the NetBeans Platform community, i.e., an independent person, Heiko Boeck, unrelated to Sun Microsystems) and that the NetBeans Platform community translated that book (unpaid) to English. (That happened in the space of one very intense month.) The book was released at JavaOne and was very popular there.
Now, however, other language communities have also begun translating it. Below are the project pages where each of the translation projects is being managed (in each case by one of the members of the translation group):
- Spanish translation: http://wiki.netbeans.org/NetBeansPlatform6SpanishTranslation
- Polish translation: http://wiki.netbeans.org/NetBeansPlatform6PolishTranslation
- Czech translation: http://wiki.netbeans.org/NetBeansPlatform6CzechTranslation
Have a look at their progress, they're all in various stages but clearly making some headway. Are other language communities interested in working on a translation of the book too? How about Chinese for example? (The existing NetBeans Platform book in Chinese is slightly out of date, though still very useful and recommended.) And how about the Brazilian-Portuguese community? Volunteers are more than welcome!
Jul 10 2009, 01:53:42 PM PDT Permalink
Thursday July 09, 2009
What Java-Based Satellite Network Management Software Looks Like!
I received a set of screenshots from Sven Reimers, System Engineer and Software Architect for ND SatCom GmbH, in Germany. The screenshots show the massive network satellite application that he and his colleagues are responsible for, consisting of over 1000 NetBeans modules plugged into the NetBeans Platform. Click each one below to see a larger image.
SNM showing the wiring of the groundstation as a basis for planning:
Central view:
FC (Facility Control) better known as M&C or Element Management - live view of the groundstation and its equipment down to parameter level:
CSM (Communication Satellite Monitoring) Monitoring the transmission sent via satellite:
Watch a movie with Sven here.
Jul 09 2009, 01:32:41 PM PDT Permalink
Wednesday July 08, 2009
Wicket Plugin Ready for NetBeans IDE 6.7
I created a 'nb_67' branch on https://nbwicketsupport.dev.java.net today. I worked on the Wicket plugin in that space. Several small tweaks needed to be done to upgrade the plugin to 6.7, but now it's done. I tried it out on Ubuntu and then Ken Ganfield, technical writer colleague, tried it on his Mac. No problems.
Go here to download the ZIP containing the three NBM files you need to install:
http://plugins.netbeans.org/PluginPortal/faces/PluginDetailPage.jsp?pluginid=3586
Some small differences between this release and the previous:
- It works for 6.7 because I upgraded the version numbers of the NetBeans APIs used by the plugin. (The problem around pre61completion module can be fixed by updating the dependencies to their current version, see here.)
- It only works for 6.7 because some APIs used are new compared to the previous version, especially the Classpath API, which wasn't there previously, with the applicable class being found in a different JAR at that time.
- JARs for 1.4 RC-5 (instead of 1.4 RC-2 as before) are included. If you don't like this version, that's fine, then simply download the JARs you want from the Wicket site and add those to the NetBeans IDE Library Manager instead of the ones that the plugin provides.
- Fewer JARs are included than before, maybe that will cause problems. Now, instead of a very long list of JARs bundled with Wicket distros, you only get the absolute minimum, the core Wicket JAR and the two mandatory logging JARs. (Thanks to Jesse Sightler for some insight and this reference.) The others you can download yourself. Or if there's enough disagreement, I'll put them back. (Or anyone else can too, of course.)
Some pics, the first showing the extension to the New Web Application wizard...
...with the second showing exactly what you get at the end of the above:
You should be able to deploy the above immediately, without any coding or configuring whatsoever.
And there are some special tools in the IDE for Wicket, such as the Navigator by Tim in the bottom left below, showing the Wicket IDs, letting you click them to navigate to the relevant place in the file:
Make sure that, when you click the "Download" button on the plugin page, you end up with "Wicket4NB67-2.zip", which will also get you Javadoc support for Wicket classes...
...as well as the ability to navigate into the Wicket sources (by holding down the Ctrl key and clicking on the reference to the class you're interested in):
Known issues: The logging sample by Tim is broken, somehow. Whoever fixes it wins a NetBeans pen. (Let me know how to fix it and I will send you a NetBeans pen. Or fix it and commit the changes yourself, which is even better.) By the way, I didn't manage to deploy Wicket to GlassFish v 2.1, although prelude 3 didn't have a problem.
For future reference, this is where I found various Wicket JARs.
If, in a week or two, no serious problems remain, I will prepare the plugin for inclusion in the Plugin Portal Update Center, so that it can be installed without your needing to download it from the Plugin Portal.
Jul 08 2009, 09:08:00 AM PDT Permalink
Tuesday July 07, 2009
Anagram Game Meets Visual Library
The most famous example in the NetBeans Platform world is the Anagram Game. That's a small Swing app shipped with NetBeans IDE that is used, over and over again, in NetBeans Platform trainings to illustrate small porting examples to the NetBeans Platform. However, have you ever seen it look like this:
That's what David Simonek did to it (plus a few very small tweaks by me) for a recent training at the Charles University in Prague. (See pictures from that course here.) David is one of the original NetBeans Platform engineers and he is also one of the NetBeans Platform Trainers.
This is what the source structure of the sample looks like:
In other words, now even the Visual Library can be integrated into the Anagram Game sample! Hurray. It's at least a nice possibility if you're giving NetBeans Platform trainings.
Get the sources here:
http://kenai.com/projects/nb-visualanagram
And even if you're not a NetBeans Platform trainer, this example might still be useful to you in the context of learning about the Visual Library.
Jul 07 2009, 10:19:11 AM PDT Permalink
Monday July 06, 2009
Courses on the NetBeans APIs
A list of courses available for learning the NetBeans APIs:
- NetBeans Platform for Desktop Java Development (DTJ-2601) by Sun Learning Services
- NetBeans Platform Certified Training by trainers from the NetBeans Platform community.
- Eppleton 'NetBeans Rich Client Platform Development' by Eppleton in Germany.
- Orientation in Objects 'Entwicklung met NetBeans' by OIO in Germany.
- Seges 'NetBeans Platform' Training by Seges in Slovakia.
In addition, several screencasts and tutorials on platform.netbeans.org are specifically focused on getting you started with the NetBeans Platform, such as the Top 10 NetBeans APIs series. Also, a course on javapassion.com is forthcoming.
There are probably more. Please let me (geertjan DOT wielenga AT sun DOT com) know if anyone knows of others.
Jul 06 2009, 01:48:30 AM PDT Permalink