XML Reference Guide

Javascript is an easier language to learn and use than Java.

Right?

Well, kind of. True, JavaScript is easier to use than Java because it's not compiled and you can use it in the browser and all that, but if you're trying to build complex web-based applications, there's just something about it that makes it a pain in the backside. Maybe it's the lack of debugging, or the fact that it is, essentially, a procedural language, no matter how object-oriented you try and make it.

On the other hand, Java gives you debugging and natural object oriented-ness, but using it in the browser isn't a trivial task.

But what if you could do both? What if you could write your applications in Java and then port them over to JavaScript with the touch of the button? And what if that converted JavaScript was cross-browser, JDK-independent, serverless code? yes"> Wouldn't that be lovely?

You bet it would. And that's what you get with the Google Web Toolkit, an interesting little tool that's been quietly making the rounds. It seems complicated when you first try and use it because all of the official documentation is reference-based rather than tutorial-based, but once you get the hang of it, it's quite simple, really.

I've spent the weekend delving into this little beauty, and I've got to tell you, it's delicious.

The toolkit works like this: you create an application using the provided script. That application includes a small HTTP server and specialized browser. These two pieces enable you to write Java code that represents what should happen in the browser, save it, and run it in the browser. (No, I didn't forget to compile it. You actually run it without specifically stopping to compile.) When the application is complete, use the provided script to compile it into JavaScript you can include on your page. Period.

Let's take a look at how that works.

1. Start by downloading the toolkit, which is available at http://code.google.com/webtoolkit/download.html.
2. Unzip it into the directory of your choice and navigate to its root directory in a command window.
3. Create a new application. You have the choice of creating an application to edit by hand, or of creating a project you can import into the Eclipse IDE for actual debugging, and even JUnit testing. To keep things simple, we'll use a straight application:

   >>>applicationcreator com.informit.client.GiftDemo
   Created file C:\gwt-windows-1.0.21\src\com\informit\GiftDemo.gwt.xml
   Created file C:\gwt\gwt-windows-1.0.21\src\com\informit\public\GiftDemo.html
   Created file C:\gwt\gwt-windows-1.0.21\src\com\informit\client\GiftDemo.java
   Created file C:\gwt\gwt-windows-1.0.21\GiftDemo-shell.cmd
   Created file C:\gwt\gwt-windows-1.0.21\GiftDemo-compile.cmd

   These five pieces are a complete (though simple) application. Starting at the bottom, the GiftDemo-compile.cmd script compiles the application into its final JavaScript form when you're finished working on it. The GiftDemo-shell.cmd script enbles you to run the application, as we'll see in a moment. GiftDemo.java is the actual Java code. (Note that the tool will force you to use client as the final component of your package name, even though the overall toolkit doesn't require it.) Giftdemo.html is the HTML page hosting the resulting Javascript, and GiftDemo.gwt.xml is a descriptor file that tells the toolkit what's going on.
4. OK, now we're ready to see it in action. Run the GiftDemo-shell.cmd script. You should see two windows pop up, including a specialized browser, as seen in Figure 1:


If you click the “Click me” button, you'll see “Hello World” text appear next to it. Click it again, and the text disappears. Not a tremendously complex application, surely, but it's someplace to start.

If we look at the GiftDemo.java file, we see it's fairly straightforward:

package com.informit.client;  

import com.google.gwt.core.client.EntryPoint;  
import com.google.gwt.user.client.ui.Button;  
import com.google.gwt.user.client.ui.ClickListener;  
import com.google.gwt.user.client.ui.Label;  
import com.google.gwt.user.client.ui.RootPanel;  
import com.google.gwt.user.client.ui.Widget;  

/**
  * Entry point classes define <code>onModuleLoad()</code>.
  */
  
  public class GiftDemo implements EntryPoint {  

  /**  
    * This is the entry point method.  
    */  

  public void onModuleLoad() {  
    final Button button = new Button("Click me");  
    final Label label = new Label();  

    button.addClickListener(new ClickListener() {  
        public void onClick(Widget sender) {  
           if (label.getText().equals(""))  
               label.setText("Hello World!");  
           else  
               label.setText("");  
        }  
    });  

    // Assume that the host HTML has elements defined whose  
    // IDs are "slot1", "slot2".  In a real app, you probably would not want  
    // to hard-code IDs. Instead, you could, for example, search for all   
    // elements with a particular CSS class and replace them with widgets.  
    //  

    RootPanel.get("slot1").add(button);  
    RootPanel.get("slot2").add(label);  
  }  
}

Starting at the top, notice that Google has created its own implementation of various classes such as buttons, text labels, and various form elements, as well as more Java-ish classes like Panel. This is just a tiny subset. You can use any Java code or objects in your Java application, but not everything is translatable into JavaScript, so try to stick with the GWT classes as much as possible, or at least with the translatable classes listed at http://code.google.com/webtoolkit/documentation/jre.html.

Next we have the class itself, which implements the EntryPoint interface. Any class that serves as the “main base,” so to speak, of an application, must implement EntryPoint, and as such, the onModuleLoad() method, which defines what happens when the user pulls up the page.

In this case, what happens is that we create a Button and a Label object. The button is an actual HTML button, rather than a Java emulation of an HTML button, but rather than specifying its behavior using the onclick handler, we can do it in true Java style, adding a listener object.

The listener object implements the onClick() method, which in this case checks the contents of the label and reacts accordingly.

Of course, so far we haven't actually added either object to the page. To do that, we'll use the add() method for the RootPanel, which represents the page itself. Ultimately, the toolkit gives you enormous power in laying out objects, including panel types that lay sequentially added widgets out horizontally, vertically, or in a grid. Some panel types, which we'll see later, include functionality that's a nightmare to do on your own. For example, the TabPanel easily builds a tab-based page, where content appears based on the tab clicked by the user. (Check out the sample applications that come with the toolkit for an idea of what you can do.)

You also have the ability to drop widgets into specific places on your page. For example, here we see that we're specifically requesting elements with an id value of slot1 and slot2. The GiftDemo.html page includes HTML that references those values:

<h1>GiftDemo</h1>  

  
  <p>This is an example of a host page for the GiftDemo application.   
  You can attach a Web Toolkit module to any HTML page you like,   
  making it easy to add bits of AJAX functionality to existing pages   
  without starting from scratch.</p>  

  <table align=center>  
     <tr>  
         <td id="slot1"></td>

         <td id="slot2"></td>  
     </tr>  
  </table>

In part 2 we'll get into the actual coding of an application, using Ajax, and so on, but before we do that, we need to know how to export this into its pure JavaScript form. To do that, we use the GiftDemo-compile.cmd script:

>>>>GiftDemo-compile
Output will be written into C:\gwt-windows-1.0.21\www\com.informit.GiftDemo
Copying all files found on public path
Compilation succeeded

This process drops about a dozen files into the com.informit.GiftDemo directory, which you can then copy, lock, stock, and barrel, to your web server. You can also view them directly in your actual browser, as opposed to the special browser that comes with the toolkit.

Next up, we create a new application that demonstrates some of the cool capabilities of GWT, such as manipulatable pages and even easy -- very easy! -- Ajax.