NetBeans Editor Component Palette Module Tutorial

This tutorial demonstrates how to create a component palette that provides drag-and-drop code snippets for a new file type. Code snippets serve to speed up coding. The IDE provides a component palette for JSP files, HTML files, and Form files. In this tutorial, you learn how to create a component palette for Java source files.

Note: This document uses NetBeans Platform 7.1 and NetBeans IDE 7.1. If you are using an earlier version, see the previous version of this document.

Contents

Content on this page applies to NetBeans IDE 7.1

To follow this tutorial, you need the software and resources listed in the following table.

Software or Resource Version Required
NetBeans IDE version 7.1
Java Developer Kit (JDK) version 6

Introduction to Component Palettes

In this tutorial, you implement several classes provided by the NetBeans Palette API. Then you register the new component palette in the layer.xml file, for the text/x-java MIME type. The palette that you create in this way will only be visible if a Java source file is open.

If you do not want to create a new component palette, but only want to add a code snippet to an existing component palette, see the NetBeans Code Snippet Module Tutorial.

Setting up the Module Project

Before you start writing the module, you have to make sure you that your project is set up correctly. The IDE provides a wizard that sets up all the basic files needed for a module.

  1. Choose File > New Project (Ctrl+Shift+N). Under Categories, select NetBeans Modules. Under Projects, select Module. Click Next.
  2. In the Name and Location panel, type JavaSourceFilePalette in the Project Name field. Change the Project Location to any directory on your computer. Click Next.
  3. In the Basic Module Configuration panel, type org.netbeans.modules.javasourcefilepalette in Code Name Base. Click Finish.

The IDE creates the JavaSourceFilePalette project. The project contains all of your sources and project metadata, such as the project's Ant build script. 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).

Creating the Component Palette and Code Snippets

Specifying the Module's Dependencies

You will need to subclass several classes that belong to NetBeans APIs. Each has to be declared as a module dependency. Use the Project Properties dialog box for this purpose, as described below.

  1. In the Projects window, right-click the JavaSourceFilePalette project node and choose Properties. In the Project Properties dialog box, click Libraries.
  2. For each of the following APIs, click "Add...", select the name from the Module list, and then click OK to confirm it:

    • Common Palette
    • Dialogs API
    • Lookup API
    • MIME Lookup API
    • Nodes API
    • Text API
    • UI Utilities API
    • Utilities API
  3. Click OK to exit the Project Properties dialog box.
  4. In the Projects window, expand the Important Files node, double-click the Project Metadata node, and note the long list of APIs that you selected have been declared as module dependencies.

Creating the Component Palette

Component Palettes are defined by the NetBeans Palette API. Implementing the NetBeans Palette API for this tutorial means implementing the following NetBeans Palette API classes:

File Description
PaletteFactory Creates a new instance of the Component Palette. To do so, it invokes the createPalette method which creates a new palette from a specified folder registered in the layer.xml.
PaletteController Provides access to data in the Component Palette.
PaletteActions Provides the actions on the palette, categories, and items in the palette.

To use the Palette API to create the palette in this tutorial, take the following steps:

  1. Right-click the JavaSourceFilePalette project node and choose New > Java Class. Create a Java file called JavaSourceFileLayerPaletteFactory.
  2. Replace the default content of the JavaSourceFileLayerPaletteFactory.java file with the following:
    public class JavaSourceFileLayerPaletteFactory {
        
        //Name of the folder in the layer.xml file 
        //that is the root of the palette:
        public static final String JAVA_PALETTE_FOLDER = "JavaPalette";
    
        private static PaletteController palette = null;
    
        //Register the palette for the text/x-java MIME type:
        @MimeRegistration(mimeType = "text/x-java", service = PaletteController.class)
        public static PaletteController createPalette() {
            try {
                if (null == palette)
                    palette = PaletteFactory.createPalette(
                            JAVA_PALETTE_FOLDER, 
                            new MyActions());
                return palette;
            } catch (IOException ex) {
                Exceptions.printStackTrace(ex);
            }
            return null;
        }
    
        private static class MyActions extends PaletteActions {
    
            //Add new buttons to the Palette Manager here:
            @Override
            public Action[] getImportActions() {
                return null;
            }
    
            //Add new contextual menu items to the palette here:
            @Override
            public Action[] getCustomPaletteActions() {
                return null;
            }
    
            //Add new contextual menu items for palette categories here:
            @Override
            public Action[] getCustomCategoryActions(Lookup arg0) {
                return null;
            }
    
            //Add new contextual menu items for palette items here:
            @Override
            public Action[] getCustomItemActions(Lookup arg0) {
                return null;
            }
    
            //Define the double-click action here:
            @Override
            public Action getPreferredAction(Lookup arg0) {
                return null;
            }
    
        }
        
    }

Adding a DragAndDropHandler

In this section, we change the PaletteController, in the code above, and add a DragAndDropHandler. In doing so, we will let the user drag code snippets FROM the editor INTO the palette:

@MimeRegistration(mimeType = "text/x-java", service = PaletteController.class)
public static PaletteController createPalette() {
    try {
        if (null == palette) {
            //Add null for the PaletteFilter, which we are not using here,
            //and then instantiate your implementation of the DragAndDropHandler:
            palette = PaletteFactory.createPalette(
                        JAVA_PALETTE_FOLDER,
                        new MyActions(),
                        null,
                        new MyDragAndDropHandler()); 
        }
        return palette;
    } catch (IOException ex) {
        Exceptions.printStackTrace(ex);
    }
    return null;
}

//Definition of the DragAndDropHandler:
private static class MyDragAndDropHandler extends DragAndDropHandler {

    MyDragAndDropHandler() {
        super(true);
    }

    //Maybe you don't like the default 'add to palette' implementation,
    //so you could create your own here:
    @Override
    public void customize(ExTransferable t, Lookup item) {
    }

}

The above default implementation is all you need. Now the user will be able to drag from the editor into the palette.

Creating the Code Snippets

Each code snippet requires the following files:

  • A Java class that defines the piece of code to be dragged into the Source Editor. This Java class must refer to JavaSourceFilePaletteUtilities.java, which defines how the piece of code should be inserted. For example, indentation and formatting are defined here.
  • Optionally, a customizer where the user can type something that will be added to the snippet, such as comments.
  • A properties file that defines the labels and tooltips.
  • A 16x16 pixel image for the 'Small Icon' display.
  • A 32x32 pixel image for the 'Big Icon' display.

After you have created or added the above files to the NetBeans module, you declare them in a resource declaration XML file, which you register in the NetBeans System Filesystem by using the layer.xml file, as follows:

<folder name="JavaPalette">
    <folder name="Items">
        <attr name="SystemFileSystem.localizingBundle" stringvalue="org.netbeans.modules.javasourcefilepalette.Bundle"/>
        <file name="Item.xml" url="resources/Item.xml">
            <attr name="SystemFileSystem.localizingBundle" stringvalue="org.netbeans.modules.javasourcefilepalette.Bundle"/>
        </file>
    </folder>
</folder>

For all the details on the items above, work through the NetBeans Code Snippet Module Tutorial.

Building and Installing the Module

The IDE uses an Ant build script to build and install your module. The build script is created for you when you create the module project.

  1. In the Projects window, right-click the JavaSourceFilePalette project and choose Run. The module is built and installed in the target platform. The target platform opens so that you can try out your new module. The default target platform is the installation used by the current instance of the development IDE.

  2. Verify that the module is correctly installed by using it.

Next Steps

For more information about creating and developing NetBeans modules, see the following resources:

Project Features

Project Links

About this Project

Platform was started in November 2009, is owned by Antonin Nebuzelsky, and has 149 members.
By use of this website, you agree to the NetBeans Policies and Terms of Use (revision 20160708.bf2ac18). © 2014, Oracle Corporation and/or its affiliates. Sponsored by Oracle logo
 
 
Close
loading
Please Confirm
Close