Skip navigation

Monthly Archives: September 2006

Hi all, this post comes after a long time. I had decided to blog once a week, but work has kept me away from doing it so far.

Anyway, I have been hanging around the Netbeans Platform more than ever now, and am writing a couple of Project Templates. Wow, it has been an awesome ride and my respect for developer tools has increased multifold. To write cool code is one thing, but writing cool code which is extensible is a real achievement. There are several places in the Netbeans Platform where you get such "Aha" moments, beautiful extensible code. It’s a fantastic place to see how to write good Java code.

So, finally to the topic of this post.

Project Customizers

Every project will have a set of properties that the user can customize. Let’s take the example of a standard Java application project in Netbeans. You can customize the libraries that are on the compile time class path, and you can also choose which Java platform you want to use for the project. In this post, I will run through the steps to create a customizer for your own project templates. Here’s a screenshot of the Project Properties UI for a Java application project.

These GUI dialogs are called Project Customizers in the Netbeans Platform parlance.

Now, almost every project type needs a customizer. And almost all project customizers will have the same UI structure. A Tree View showing options (called categories) in the left hand side and a panel associated with each category for editing the properites associated with that category. So, it doesn’t make much sense asking the Project Template developer to do this UI styling stuff again and again.

Netbeans Project Support API module provides support for writing customizers through the org.netbeans.spi.project.ui.CustomizerProvider interface, which will do the work of UI styling for you. All you (Project Template developer) have to do is to provide a set of categories and a JPanel for each category for manipulating properties.

So, to create a customizer for my project template, I write an implementation of the CustomizerProvider as shown below.

import org.netbeans.spi.project.ui.CustomizerProvider;

* My Project Template's Customizer
public class MyProjectCustomizerImpl implements CustomizerProvider {

public MyProjectCustomizerImpl() {

* This method will be called by the platformto display the customizer
* when the user selects "Project Properties" option
public void showCustomizer() {

The showCustomizer() method is where all the action happens. This method is called by the Netbeans Project System when the user chooses the "Project Properties" option.

But wait a minute! How on earth did the Project system come to know about this Customizer of mine? Well, it’s through the Project’s lookup! Here’s how I let the project system know about my Customizer:

public class MyProject implements Project {


public Lookup getLookup() {
if(lookup == null) {
= Lookups.fixed(new Object[] {
new Info(), // Project Information
new MyProjectCustomizerImpl(), // Customizer
new MyLogicalViewProvider(), // Ze Logicale View

return lookup;

Now to implement the logic for the customizer. I want two categories for my customizer.

  • Basic Files – To set the Java Platform support options
  • Important Files – To set the README.TXT file for my project

So, I will create two categories in my customizer class like this:

public class MyProjectCustomizerImpl implements CustomizerProvider {

private ProjectCustomizer.Category[] categories;
private ProjectCustomizer.CategoryComponentProvider panelProvider;

// Names of categories
private static final String IMPORTANT_FILES_CATEGORY = "ImpFilesCategory";
private static final String BASICS_FILES_CATEGORY = "BasicsFilesCategory";

private void init() {
ProjectCustomizer.Category importantFiles
= ProjectCustomizer.Category.create(
"Important Files",

ProjectCustomizer.Category basicsFiles
= ProjectCustomizer.Category.create(
"Plugin Basics",

= new ProjectCustomizer.Category[] {

Map panels
= new HashMap();
new ImportantFilesVisual());
new BasicsVisual());

= new PanelProvider(panels);

As you can see in the code above, I have created two ProjectCustomizer.Category instances, one for each category. Then I create a Map to associate the properties manipulation UI (JPanels that I have created) with the categories. Here are the panels that I have:

What about the PanelProvider class?

Well, its here inside the MyProjectCustomizerImpl class:

private static class PanelProvider implements ProjectCustomizer.CategoryComponentProvider {
private Map panels;

private JPanel EMPTY_PANEL = new JPanel();

public PanelProvider(Map panels) {
this.panels = panels;

public JComponent create(ProjectCustomizer.Category category) {
JComponent panel
= (JComponent) panels.get(category);
return panel == null ? EMPTY_PANEL : panel;


I don’t think it needs any explaining. Quite easy, isn’t it?

Now, we are almost there. The only thing left is to fill out the necessary details in the showCustomizer() method to actually show the customizer.

public void showCustomizer() {

OptionListener listener
= new OptionListener(project);
Dialog dialog
= ProjectCustomizer.createCustomizerDialog(categories, panelProvider,
null, listener, null);



First we initialize the categories and their UI by calling the init() method. The ProjectCustomizer.createCustomizerDialog() method gives us a nice Dialog which we just display on screen to take the customizations from the user.

Oh, and about the OptionListener, well, somebody has to listen to the OK and Cancel button events on the Dialog, right? Here’s the code for the OptionListener:

private class OptionListener extends WindowAdapter implements ActionListener {
private Project project;

OptionListener(Project project) {
this.project = project;

public void actionPerformed(ActionEvent e) {
// Close and dispose the dialog

public void windowClosed(WindowEvent e) {


public void windowClosing(WindowEvent e) {
// Close and dispose the dialog


Now the final step. We will need to register an action on the project node so that our customizer gets invoked. Add the following to the root node in your project’s logical view (assuming your root node is a sub class of AbstractNode or FilterNode):

Here’s the output:

Here are the Javadoc links for the Netbeans Platform classes used here:

Acknowledgement: The code above is mostly taken from the Netbeans J2SEProject Support Module. I am just documenting my learnings here. Thanks to Ibon Urrutia for pointing out some errors in the original post.


Recently, I got a chance to present about my latest hobby – Netbeans Platform, for the Sun University Relations Programme, an effort by Sun to reach out to Indian universities. I gave a small presentation, largely adapted from Roman Strobl’s fantastic Netbeans 5.0 demo series, to a gang of 60 students from Pondicherry, visiting Sun’s India Engineering Center, Bangalore as part of the programme. 

Though IMHO, Sun is a bit late to enter this field(Microsoft was the pioneer in this field in India, I must accept), I have realized that we have a definite edge over other companies which try to evangelize their products amongst students.

I would be a fool to say that Sun’s product offerings are always technically more innovative or complex than competitors’ offerings. No. Our competitors have some great stuff too. Then what gives us an edge?

The answer is Open Source.

As a part of Sun’s initiative, almost all developer tools are going to be open sourced. OpenSolaris has set the trend. Netbeans has establised a milestone, and open sourcing of Java is the zenith of Sun’s commitment to open source.

So, when we present about some technology to these “free radicals”, we don’t urge them to just use it, rather we can urge them to come, join us and improve it.

Students get a feeling that they are not just customers, they are our developers! And they just love this 🙂