NetBeans Platform Plugin Quick Start

Welcome to NetBeans plugin development!

This tutorial provides a simple and quick introduction to
the NetBeans plugin development workflow by walking you through the creation
of a new toolbar for any NetBeans Platform application. Once you are done with this tutorial, you
will have a general understanding of how to create, build, and install
plugins for the NetBeans Platform.

After you finish this tutorial, you can move on to the
NetBeans Platform learning trail.
The learning trail provides comprehensive tutorials
that highlight a wide range of NetBeans APIs for a variety of application types.
If you do not need to do a "Hello World" tutorial, you can skip the instructions
that follow and jump straight to the learning trail.

When the user presses Enter in the toolbar above, the IDE's default
browser opens and the text in the toolbar is sent to a Google search,
with the results available in the open browser.

To create this toolbar, you
will use the NetBeans APIs to enhance
the NetBeans Platform's feature set. Specifically, you will create and register an action invoked by
a button created by the NetBeans Platform in the toolbar. You will then create
a JPanel containing a JLabel
and JTextField as GUI components.
Finally, you will implement Presenter.Toolbar to
return the JPanel so that it displays in the toolbar, instead of the button.

Do some background reading before diving into
this tutorial. In particular, read the Modules API Reference document,
which explains what modules are and provides some
context for this tutorial. Also note that there is an extensive Reference Material section
on the NetBeans Platform Learning Trail.

Setting up the Module Project

We begin by creating the source structure common to all NetBeans Platform modules. Read the Modules API Reference for details.

NetBeans Platform Application. A project that groups a set of
module projects and library wrapper module projects that have dependencies on
each other, and lets you deploy them together as a unit. Automatically included
are a subset of the modules that make up the NetBeans Platform.

Module Suite. Same as above, except that the pre-included modules are
more than only those relating to the NetBeans Platform—in this case,
all the modules that make up NetBeans IDE are included as well.

Library Wrapper Module. A project that puts a library JAR file on its classpath and exports some or all of the JAR file's packages from the module as public packages.

Module. A project for implementing the functionality, business logic, and user interface of a module or application built on the NetBeans Platform.

Click Next.

In the Name and Location panel:

In the Project Name field, type GoogleToolbar.

In the Project Location field, change the value to any directory on your computer where
the module will be stored.

If you see the below, click Next.

In the Basic Module Configuration panel:

Type org.myorg.googletoolbar
in "Code Name Base", which defines the unique string identifying the
module you are creating. The code name base is also used as the main
package of the module, i.e., your main package will be "org.myorg.googletoolbar".

Do not select the "Generate OSGi Bundle" checkbox, since we
will be using the default NetBeans module system, rather than OSGi.

If you see the above, click Finish.

The IDE creates the GoogleToolbar project:

A "project" is
a NetBeans IDE compilation/deployment unit. It contains a Build Script, as shown above,
which on disk is named "build.xml"
file. This is an Ant script for compiling and running the project.
The project contains all of your sources. The project opens in the IDE. You can view its logical
structure in the Projects window (Ctrl+1) and its file structure in the Files window (Ctrl+2).

If you expand the Important Files node, you can open the Module Manifest, shown above, which has
this content:

Coding the Module

Creating the Action

In this section, you use the New Action wizard in NetBeans IDE to create a new Action.
An Action is a piece of code invoked by the user to do something
in the application. An Action can be invoked from a menu item, toolbar button,
and keyboard shortcut in the application.

Note: As you will see,
the New Action wizard creates a Java class with annotations. At compile-time,
the annotations are converted into XML elements in a file contributed
to the virtual filesystem of the application, which is how an Action is
registered in the application. For many questions and answers
relating to the creation and registration of Actions in the NetBeans Platform, see Actions: How to add things to Files, Folders, Menus, Toolbars and more
in the NetBeans Platform Wiki.

Right-click the GoogleToolbar project node and choose New > Action. If Action is not displayed, access it by
choosing Other, then in the New File wizard under Categories, select Module Development
and then Action:

Click Next.

In the Action Type panel:

Keep the default setting, which will let the Action be unconditionally enabled,
as shown below.

Click Next.

In the GUI Registration panel:

Select File from the Category drop-down list. The Category drop-down
list controls where an action is shown in the Keyboard Shortcuts editor in the IDE.

Deselect
Global Menu Item because we will not need a menu item.

Select Global Toolbar Button. In the Toolbar drop-down list, select File, then
in the Position drop-down list, select the toolbar button's position within the toolbar, such as
the one shown below.

Click Next.

In the Name, Icon, and Location panel:

In the Class Name field, type GoogleActionListener

In the Display Name field, type Google

In the Icon field, browse to an icon that has a dimension of 16x16 pixels.

If needed, here are two icons you can use:

16x16:

24x24:

However,
note that in the end, you will not use the icon at all once you have created the toolbar—instead, you will display
the JPanel that you create in the next
section.

The Name, Icon, and Location panel of the New Action wizard should now look like this:

Click Finish. The module source structure is now as follows:

GoogleActionListener.java, which you should see in the Projects window, has this content:

Note: When you build the module, which is done automatically in the next step
when you run the module, the class annotations
that you see above will be converted to XML tags in a file
that will be contributed to the virtual filesystem of
the application. The XML file will be named "generated-layer.xml" and
will be found in the "build\classes\META-INF"
folder of your module, which you can see if the Files window (Ctrl-2)
is open in the IDE. This file is created at compile-time and contains
XML entries generated from the NetBeans annotations that you have defined in
your Java classes. Together with the "layer.xml" file that your module can
optionally provide, the "generated-layer.xml" file defines the contributions
that the module makes to the virtual filesystem. Read about the virtual filesystem here,
in the NetBeans
Platform Wiki. Aside from the javadoc link above, also
see this article for more information on the @Messages annotation.

In the Projects window, right-click the GoogleToolbar project node and choose Run.
The module is built and installed in a new instance of the IDE (which is currently set to be the target
platform). By default, the default target platform is the version of the IDE you are currently working
in. The target platform opens so that you can try out the new module. You should
be able to see your button and click it:

In the next section, you change the JButton that has been created
for you in the toolbar by the NetBeans Platform with your own JComponent.

Creating the Toolbar

In this section, you create a JPanel that will replace
the JButton that the NetBeans Platform created for you
in the previous section.

In the Name and Location panel, type GooglePanel as the Class Name and select the package
from the drop-down list:

Click Finish. GooglePanel.java is added to the package and is
opened in the Design view in the Source Editor.

Place the cursor at the bottom right-hand corner of the JPanel, then select the JPanel and drag the
cursor to resize it, so that its width and length resemble that of a toolbar, as shown below:

Drag a JTextField item and a JLabel item from the Palette (Ctrl+Shift+8) directly into the JPanel,
then resize the JPanel and the other two items so that they fit snugly together. Finally, press F2 on the
JLabel and change its text to Google:, then delete the default text in the JTextField. (If
you click F2 over the JLabel and the JTextField, their display text will become editable.)
Your JPanel should now resemble the image shown below:

Double-click on the JTextField (or right-click on it and choose Events > Action > actionPerformed). This generates a
jTextField1ActionPerformed()
method in the GooglePanel.java source code, which displays in the Source Editor.
Fill out the
jTextField1ActionPerformed method as follows (inserted text shown in bold):

Because the JPanel you have created is the component that will be rendered in the toolbar,
you need
to implement Presenter.Toolbar
in the ActionListener you created earlier, in order to display the JPanel
in the toolbar. Change the signature of Open GoogleActionListener.java. so
that Presenter.Toolbar is implemented.
When using Presenter.Toolbar, you need to extend AbstractAction, instead of
implementing ActionListener. Also, you can
delete the "iconBase" attribute (as well as the icons from the source tree)
because you no longer need an icon in this scenario.

Run the module again. This time, instead of a JButton, you
should see your JPanel. Type a search string in the text field:

Press Enter. The IDE's default browser starts up, if you have set one
in the Options window. Above, the embedded browser is shown in action.
The Google URL and your search string are sent to the
browser and a search is performed. When the search results are returned, you can view them in the browser.

In this section, you have created a JPanel that displays a JTextField
and a JLabel. You have presented it in the NetBeans toolbar, thanks to
the Presenter.Toolbar class. When the user presses Enter in
the JTextField, its content
is sent to a Google search. The HTML browser opens and you
see the result of the Google search. The ActionListener is used
to integrate the JPanel within the application's toolbar, as registered
via the annotations in the ActionListener.

See Also

This concludes the NetBeans Plugin Quick Start. This document has described
how to create a plugin that adds a Google Search toolbar to the IDE.
For more information about creating and developing plugins, see the following resources: