Developing GNOME Applications with Java

The original announcement of the GNOME Desktop Project in 1997 stated the following intention, “to use GTK/Scheme bindings for coding small utilities and applications”. Since then, the GNOME development platform has provided tools to develop using several alternatives to C. C++, Java, Perl and Python all are supported by the official GNOME distribution. In addition, the Mono Project provides tools necessary for developing GNOME applications using the C# programming language. All of these options are becoming quite popular. The GNOME interfaces for many of the system configuration tools for the Fedora Project, for example, are written in Python, and many new applications are being written in C#. This article describes how to create GNOME applications using the free Java compiler from the GNU Compiler Collection. Although this article focuses on Java, the techniques described revolve around the GLADE User Interface Builder and may be used with any of the bindings supported by the GNOME Project.

The GNU Compiler for the Java Programming Language (gcc-java) is a Java development environment distributed under the GNU General Public License. Because gcc-java is free software, it is developed independently of Sun Microsystems' Java efforts. As a result of this, gcc-java does not yet implement 100% of the Java standard. For example, support for the Abstract Window Toolkit (AWT) is not yet complete. Despite its current shortcomings, gcc-java shows great promise as the foundation of a completely free Java stack, and it already can be used to build many real-world applications; see the on-line Resources for examples.

Unlike many Java compilers, gcc-java can produce both Java bytecode and a native, platform-specific executable. In the latter case, the executable is linked against gcc-java's libgcj. libgcj is a library containing the core Java class libraries and a garbage collector. In addition, libgcj contains a bytecode interpreter so natively compiled Java applications can interact with Java bytecode libraries.

public class HelloWorld {
	public static void main(String[] args) {
		System.out.println("Hello, World!");
	}
}

The simple Java source code in Listing 1 can be compiled into Java bytecode with gcj -C HelloWorld.java and interpreted using gij HelloWorld. The same source code can be compiled into a native executable using gcj --main=HelloWorld -o HelloWorld HelloWorld.java and executed using ./HelloWorld. This article avoids including import and other trivial statements in Java code listings; see Resources for the full source files.

public class ExampleAWT extends Frame {
 ExampleAWT() {
  super("AWT");

  Label msgLabel = new Label("Quit?");
  Button yesButton = new Button("Yes");
  Button noButton = new Button("No");

  Panel buttonbox = new Panel();
  buttonbox.setLayout(new FlowLayout());
  buttonbox.add(yesButton);
  buttonbox.add(noButton);

  Panel msgbox = new Panel();
  msgbox.setLayout(new FlowLayout());
  msgbox.add(msgLabel);

  add(msgbox, BorderLayout.NORTH);
  add(buttonbox, BorderLayout.SOUTH);

  yesButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    System.exit(0);
  }
  });

  noButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    System.exit(1);
   }
  });

  addWindowListener(new WindowAdapter() {
   public void windowClosing(WindowEvent e) {
     System.exit(0);
   }
  });
 }

 public static void main(String[] args) {
  ExampleAWT frame = new ExampleAWT();
  frame.pack();
  frame.setVisible(true);
 }
}

Sun provides two class hierarchies for developing Java applications with graphical user interfaces. The first, the Abstract Window Toolkit, has been distributed with Java since version 1.0. A picture of a gcc-java-compiled AWT application is shown in Figure 1. The corresponding source code is provided in Listing 2 and can be compiled with:

gcj --main=ExampleAWT -o ExampleAWT ExampleAWT.java

Figure 1. An AWT Application

public class ExampleSwing {
 public static void main(String[] args) {
  JFrame win = new JFrame("Swing");

  JLabel msgLabel = new JLabel("Quit?");
  JButton yesButton = new JButton("Yes");
  JButton noButton = new JButton("No");

  win.getContentPane().setLayout (new BorderLayout());

  JPanel buttonbox = new JPanel();
  buttonbox.setLayout(new FlowLayout());
  buttonbox.add(yesButton);
  buttonbox.add(noButton);

  win.getContentPane().add(msgLabel, "Center");
  win.getContentPane().add(buttonbox, "South");

  yesButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    System.exit(0);
   }
  });

  noButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    System.exit(1);
   }
  });

  win.pack();
  win.show();
 }
}

The second system, Swing, made its debut in Java 1.2. Figure 2 is a picture of the gcc-java-compiled Swing application shown in Listing 3. Listing 3 can be compiled with gcj --main=ExampleSwing -o ExampleSwing ExampleSwing.java. AWT uses the native GUI components in the host operating system to draw itself. Swing gives the user finer control over the look and feel of components, and most of the work is performed by Java.

Figure 2. A Swing application—both AWT and Swing were written so that one application would behave in a similar manner on any platform.