Products Docs & Support Community

Internationalizing a GUI Form in NetBeans IDE 5.5

The following tutorial takes you through some of the basic steps of setting an Internationalization in NetBeans IDE 5.5. We will setup Internationalization for one Form and later on designing such set Form, then we internationalize the whole Project which contains several Forms in few packages. The Internationalization is possible to set by two ways. The first part of this tutorial describes automatic Internationalization and the second one uses a special wizard.

Expected duration: 30 minutes


This tutorial assumes you have some basic knowledge of, or programming experience with, the following technologies:

  • NetBeans IDE

This tutorial describes you:

Principle of Internationalization

Internationalization permits applications to be adapted to various languages and regions without requiring engineering changes or recompilation. Internationalized programs enable textual elements, such as status messages and GUI component labels, to be stored outside the source code and retrieved dynamically rather than hard-coded in the program.

You typically store your internationalized strings in properties files, in the form of key/value pairs. The key is the identifier used by the program to retrieve the text, and the value is the actual text. You create one properties file for each locale (or language) in which you translate the program. The keys are the same in each locale - only the strings are different.

The IDE provides tools for doing each of the following:

  • Inserting internationalized strings as you create a GUI form or Java program
  • Replacing all hard-coded strings in an individual file or group of files with internationalized strings

Update Pack Installation

Internationalization support is a part of the default installation of NetBeans IDE 5.5 but if you want to use special automatic Internationalization for a form, you have to install the GUI Builder Update Pack from the Beta Update Center. This update also contains a lot of other features for the GUI Builder.

Once NetBeans IDE 5.5 is running, follow these steps:

  1. From the main menu, choose Tools > Update Center.
  2. In the table of known update centers, check NetBeans Update Center Beta. (You can uncheck the others to speed the connection process.)
  3. Click Next. The IDE will connect to the update center and show all available updates.
  4. Within the Features node, select GUI Builder Update Pack for NetBeans 5.5 and click Add. All necessary modules will appear in the Include to Install list.
  5. Click Next and accept the license.
  6. Wait until the modules are downloaded and then proceed by clicking Next.
  7. Make sure all modules are selected for installation (left column with check boxes).
  8. Click Finish and let the IDE restart.

After the IDE restarts, the installation is complete and you can start using the new features.

Manual Installation (Alternative)

It is also possible to install the update pack from manually downloaded files. Just download the files linked below and then in Tools | Update Center select the option to Install Manually Downloaded Modules.

Internationalizing a GUI Form at Design Time

In this exercise we will open the demo Java application project, which contains a well-known find dialog created using the GUI Builder. Next, we will switch on automatic internationalization for Form and, in order to test our internationalized GUI form, we will add a new locale to the properties file and run the form in the non-default locale.

Opening the Example Project

  1. Download and unzip the project to any location on your computer.
  2. Choose File > Open Project (Ctrl-Shit-O), select the InternationalizeDemo folder you created in the last step, and click Open.
  3. Expand Source Packages > Demo and double-click The sample form opens in the GUI Builder.

    To view a demonstration of how to create this GUI form, click View Demo.

Switch Automatic Internationalization On

  1. Select the root node in the Inspector Window (named Form FindDialog).

  2. In the Properties window, select the checkbox in the Automatic Internationalization On property.

    When checkbox is set, the IDE creates the file in the demo package as it is set in the Properties Bundle File property. If you need to have this file in a different location, you can invoke Custom Editor (...) and choose a location or directly type the path in the property's text field.

  3. In the Projects window, double-click the node in the Projects Window or right-click the node and choose Edit.
    The properties file is opened in the Source Editor. As you can see, all appropriate Keys and Values for Form are generated. (The name of each key is derived from the form file name and the component Variable name. For example, the key FindDialog.jLabel1.text is generated for a component with the variable name jLabel1 placed in form file FindDialog. The value jLabel1 represents component's Text property in this example.

Internationalizing Individual GUI Components

We will now use the GUI builder to enter internationalized strings for the JLabels and JButtons in the form.

  1. Select the appropriate GUI component (e.g. jLabel1) in the Design Area.
  2. In the Properties window, click the ellipsis (...) button for the Text property. Note that you can also internationalize other properties that have String values, such as Mnemonic, Accessible Name, Accessible Descriptor, and ToolTip.
  3. The property editor is switched to resource bundle mode. Check that the Bundle Name field is set to demo.Bundle and the Key field contains the string FindDialog.jLabel1.text
  4. Type Find What: in the Value field.
  5. Click OK.

    Repeat the previous steps for all components so that the form looks like the following picture:

    To view a demonstration of internationalizing jLabel1 , click View Demo

  6. Note: Steps 1-5 can be done in a simpler and faster way: just double click jLabel1 in the design view, change the text from jLabel1 to Find What: ,and press Enter. The result is the same as from the steps given above.

Adding a New Locale

  1. Select the root node in the Inspector Window (the Form FindDialog node).
  2. In the Properties window, click the ellipsis (...) button for the Design Locale property
  3. Enter ES in the Country Code field.
  4. Click OK.
  5. The new locale appears below the Bundle Properties node, as shown below:

  6. In the Projects window, right-click and choose Open.
  7. Translate individual messages in the correspondent column of table to the new (e.g. Spanish) language, as shown below:

  8. Right-click the root node in the Inspector Window and choose Reload Form (or press Ctrl-R). The form is reopened and the Spanish locale is loaded in in the design, as shown below:

You can see these features in action in this Flash Demo (though it does not correspond exactly with this tutorial).

Testing a Non-Default Locale

  1. In the Projects window, right-click the InternationalizeDemo project and choose Properties.
  2. In the Categories pane, select the Run node.
  3. Enter -Duser.language=es in the VM Options field.

  4. Click OK
  5. Right-click the InternationalizeDemo project and choose Run Project

    The IDE runs the FindDialog dialog in the Spanish locale.

Internationalizing an Entire Project

Generally, we have several files in the default locale and we are asked to adapt them in order to be translated to other languages. The Internationalization Wizard is the perfect tool for this task, as it can internationalize multiple files at once. We will shows this feature on the GUI Form examples project, which contains the form created in the GUI Building Tutorial.

Creating a Samples Project

  1. Choose File > New Project or click on the New Project icon in the IDE toolbar.
  2. In the Categories pane, select the Samples > General node and in the Projects pane, select GUI Form Examples. Click Next.
  3. Enter GUIFormExamples in the Project Name field and specify the project location (e.g /space/projects).
  4. Ensure that the Set as Main Project checkbox is selected.
  5. Click Finish.

Preparing a Properties File

  1. Choose File > New File or click the New File icon in the IDE toolbar.
  2. In the Categories pane, select the Other node and in the File Types pane, choose Properties File. Click Next.
  3. Enter ContactEditor in the File Name field and specify the src/examples folder as the file location.
  4. Click Finish.

    The IDE creates the file and opens the ContactEditor(default language) file in the Source Editor.

    Repeat previous steps to create another file.

Invoking The Internationalization Wizard

  1. In the Projects window, right-click the Source Packages node and choose Tools > Internationalization > Internationalization Wizard.
  2. For demonstration purposes, select and click Remove Source(s) button.

  3. Click Next.
  4. Check if the Internationalization wizard offers the correct properties files examples.Antenna and examples.ContactEditor. If it does not, use the Select Resource button to choose the correct properties file.

  5. Click Next.
  6. All hard-coded strings are displayed in the last step of Internationalization wizard and it is possible to decide which of them will come from the properties file (use checkbox). You can further customize individual keys, values, comments, and format of replaced strings by clicking on the ellipsis (...) button for a string.

  7. Click Finish.

    Now, the internationalization of source code is finished, other locale can be added and tested as it was shown previously.

Internationalizing a Single Form

Using automatic I18n features is the easiest way to internationalize a GUI form. But if you don't have the update pack installed, or you also want to internationalize code not generated by the Form Editor, then using the Internationalize window is the way to go. (This feature works with any .java file, not just files created with the Form Editor). The next example uses the Internationalization window, which is a part of default Netbeans IDE 5.5 installation.

In this last exercise we will reuse the GUI Form Examples project and internationalize the form, which we excluded in the previous exercise. We will invoke the Internationalize dialog box to replace all hard-coded strings in this file. Finally, we will go through a short demonstration of how to insert an internationalized string in the source code when you are writing a program.

Using the Internationalize dialog box Box

  1. In the Projects window, right-click and choose Tools > Internationalization > Internationalize.

    The IDE shows Internationalization dialog box and pre-fills the first hard-coded string from the source code .

  2. Click Browse to select a particular properties file or create a new one (e.g.
  3. You can modify format of replaced string, key, value or comment if it is necessary. We'll just leave the default values.
  4. Click Replace to confirm the change and move a focus on the next hard-coded string.

    If a hard-coded string does not need to be replaced, click the Skip button

    To view a demonstration of using the Internationalize dialog box, click View Demo

Inserting a Single Internationalized String

  1. In the Projects window, right-click and choose Edit.

    The IDE opens the file in the Source Editor.

  2. Scroll through the source code and find the main method.
  3. Insert the following line in bold in the main method:
        public static void main(String args[]) {
            java.awt.EventQueue.invokeLater(new Runnable() {
                public void run() {
                    new Find().setVisible(true);
  4. Press Ctrl-Shift-J to invoke Internationalized String Dialog.
  5. For Bundle Name, click the New button, select the Source Packages > examples folder, and enter Find as the Bundle name. Then click OK. The Bundle Name field shows examples.Find.
  6. Type Start in the Key drop-down box and Start Find Dialog in the Value field. Then click OK.

  7. The IDE inserts an internationalized string:
        public static void main(String args[]) {
            java.awt.EventQueue.invokeLater(new Runnable() {
                public void run() {
                    new Find().setVisible(true);

    To view a demonstration of inserting internationalized string, click View Demo

Related Topics

For more information see the following links:

  • Java GUIs and Project Matisse Learning Trail   A full list of articles, guides and tutorials to creating Java graphical user interfaces (GUIs) using Project Matisse, the NetBeans GUI builder.
  • GUI Building Tutorial  Detailed NetBeans GUI Builder tutorial.
  • Matisse GUI Builder FAQ  A collection of useful tips and tricks for using NetBeans GUI Builder.