Skip to Content »

Tech Life of Recht » archive for August, 2006

Reading TomTom POI files from Java

  • August 30th, 2006
  • 7:12 pm

While I was messing around with GWT and Google Maps, I thought it might be a nice idea to plot POIs like the kind TomTom uses for Point of Interests - hotels, gas stations, and quite a lot of other stuff, which in many cases can be downloaded freely.

POI files (.ov2) contains longitude, latitude and a name in a (simple) binary format. The following code reads a list of POIs:

PLAIN TEXT
CODE:
  1. public class POI {
  2.     private double longitude;
  3.     private double latitude;
  4.     private String name;
  5.  
  6.     public POI(String name, double longitude, double latitude) {
  7.   this.name = name;
  8.   this.longitude = longitude;
  9.   this.latitude = latitude;
  10.     }
  11.  
  12.     public double getLatitude() {
  13.   return latitude;
  14.     }
  15.  
  16.     public double getLongitude() {
  17.   return longitude;
  18.     }
  19.  
  20.     public String getName() {
  21.   return name;
  22.     }
  23.  
  24.     public static List getPOIs(InputStream is) throws IOException {
  25.   List res = new ArrayList();
  26.   int b = -1;
  27.   while ((b = is.read())> -1) {
  28.       if (b == 0 || b == 2) {
  29.  
  30.     long total = readLong(is);
  31.  
  32.     double longitude = (double) readLong(is) / 100000.0;
  33.     double latitude = (double) readLong(is) / 100000.0;
  34.  
  35.     byte[] r = new byte[(int) total - 13];
  36.     is.read(r);
  37.  
  38.     POI p = new POI(new String(r), longitude, latitude);
  39.     res.add(p);
  40.       }
  41.   }
  42.   return res;
  43.     }
  44.  
  45.     private static long readLong(InputStream is) throws IOException {
  46.   long res = is.read();
  47.   res += is.read() <<8;
  48.   res += is.read() <<16;
  49.   res += is.read() <<24;
  50.   return res;
  51.     }
  52. }

The resulting objects' latitude and longitude can be transferred directly to a Google Map for display, or they can be used to, for example, calculate the nearest gas station.

New XDoclet module for GWT

  • August 30th, 2006
  • 6:10 pm

I've updated the GWT XDoclet module so that it supports module inheritance from other than the standard com.google.gwt.user.User class.
The new version, 0.2, is available from http://braindump.dk/gwt-xdoclet/xdoclet-gwt-module-0.2.jar.

The only change is in the @gwt.module tag:

PLAIN TEXT
CODE:
  1. /**
  2. * @gwt.module package="dk.contix.gwt" include="client,shared" inherits="dk.contix.gwt.BaseModule"
  3. */
  4. public class Module implements EntryPoint {
  5.  ...
  6. }

Label alignment and usability

  • August 24th, 2006
  • 10:57 am

I just stumbled upon this article, Label Placement in Forms, an article about how labels in forms should be placed. Pretty interesting stuff, especially because its results are based on tests on real people in a controlled environment.

Scroll Loader in GWT

  • August 17th, 2006
  • 10:04 pm

Pagination is a normal and popular method of splitting data across pages. However, a new method has emerged (I forgot where I read about it first). Instead of distributing data across several pages (which is pretty non-Ajax), you place a scrollpanel around the data and load data when the scrollbar reaches the bottom.
See an example here.

Implementing this is actually pretty easy, especially with Google Web Toolkit. I've created a custom widget called ScrollAutoLoader, which handles scroll events. When used, you can implement scroll loading like this:

PLAIN TEXT
CODE:
  1. public class Module implements EntryPoint {
  2.     private int count;
  3.     private ScrollAutoLoader loader;
  4.     public void onModuleLoad() {
  5.   final VerticalPanel panel = new VerticalPanel();
  6.  
  7.   loader = new ScrollAutoLoader(panel, new Loader() {
  8.       public void load(int offset, int limit) {
  9.     panel.add(new Label("Line " + ++count));
  10.  
  11.     loader.fill();
  12.       }
  13.   }, 5);
  14.  
  15.   loader.setHeight("300px");
  16.  
  17.   RootPanel.get().add(loader);
  18.   loader.fill();
  19.     }
  20. }

I've used the widget a couple of places, and it works pretty good. It might, however, be too slow if there are a lot of pages, as the browser tends to slow down when the inner panel becomes too large.

Getting started with GWT (the manual way)

  • August 14th, 2006
  • 10:27 pm

I thought a small tutorial on how to get started with Google Web Toolkit might be in order. The GWT package contains some utilities, but I have found that in order to actually deploy to a Tomcat, you need to do quite a bit of stuff yourself.

This tutorial is based on GWT 1.1.0, Eclipse, Tomcat and Ant. It's assumed that Tomcat is installed somewhere (simply download and unzip/untar, and you're ready to go).

Creating a project

Create a new project in Eclipse - just a regular Java project. Make sure you use separate source and build folders.

Create the following dirs:
lib
lib/build
lib/core

Copy gwt-dev-*.jar and gwt-user.jar from GWT to lib/build.
Download ant-gwt-1.1.0.jar, xdoclet-gwt-module-0.1, gwt-xdoclet-1.2.3.jar, and xjavadoc-1.1.jar and place them in lib/build.

Place gwt-servlet.jar from GWT in lib/core together with any 3rd party libs you're using.

Add all jars (both in lib/build and lib/core) to the Eclipse build path (Right click on a jar and select Build path->Add to build path).

Create the following packages in Eclipse:
dk.contix.gwt
dk.contix.gwt.client
dk.contix.gwt.shared
dk.contix.gwt.service

In the dk.contix.gwt package, create a new dir called "public" and create a new HTML file:

PLAIN TEXT
CODE:
  1. <html>
  2.   <head>
  3.     <title>Name of module</title>
  4.     <meta name="gwt:module" content="dk.contix.gwt.Module">
  5.     <link rel="stylesheet" type="text/css" href="style.css">
  6.   </head>
  7.   <body>
  8.     <script type="text/javascript" src="gwt.js"></script>
  9.   </body>
  10. </html>

The file should be called Module.html in this example.

Setting up build

To actually compile and deploy, you need a ant build.xml file. Use this file:

PLAIN TEXT
CODE:
  1. <?xml version="1.0"?>
  2. <project default="compile" name="Module" basedir=".">
  3.   <property file="build.properties"/>
  4.  
  5.   <path id="classpath">
  6.     <pathelement location="src"/>
  7.     <pathelement location="target/classes"/>
  8.     <fileset dir="lib">
  9.       <include name="**/*.jar"/>
  10.     </fileset>
  11.   </path>
  12.  
  13.   <path id="sourcepath">
  14.     <pathelement location="src"/>
  15.   </path>
  16.  
  17.   <target name="init">
  18.     <tstamp/>
  19.     <mkdir dir="target"/>
  20.     <mkdir dir="target/classes"/>
  21.     <mkdir dir="target/web"/>
  22.   </target>
  23.  
  24.   <target name="clean">
  25.     <delete dir="target"/>
  26.   </target>
  27.  
  28.   <target name="compile" depends="init,generate">
  29.     <javac classpathref="classpath" destdir="target/classes" debug="true">
  30.       <src refid="sourcepath"/>
  31.     </javac>
  32.  
  33.     <taskdef resource="dk/contix/ant/gwt/ant-gwt.xml" classpathref="classpath" />
  34.     <gwtcompile destdir="target/web" optimize="true">
  35.       <fileset dir="src">
  36.         <include name="**/*.gwt.xml"/>
  37.       </fileset>
  38.     </gwtcompile>
  39.  
  40.     <copy todir="target/classes">
  41.       <fileset dir="src">
  42.         <exclude name="**/*.java"/>
  43.       </fileset>
  44.     </copy>
  45.   </target>
  46.  
  47.   <target name="generate">
  48.     <taskdef resource="xdoclet/modules/gwt/doclet.xml" classpathref="classpath"/>
  49.     <gwtdoclet destdir="src">
  50.       <fileset dir="src">
  51.         <include name="**/*.java"/>
  52.       </fileset>
  53.       <interface/>
  54.       <async/>
  55.       <module/>
  56.       <servicefactory class="dk.contix.gwt.client.ServiceFactory"/>
  57.       <webxml output="../target/web.xml"/>
  58.     </gwtdoclet>
  59.   </target>
  60.  
  61.   <target name="deploy" depends="compile">
  62.     <fail unless="deploy.root" message="You need to define deploy.root in build.properties"/>
  63.  
  64.     <mkdir dir="${deploy.root}"/>
  65.     <mkdir dir="${deploy.root}/WEB-INF"/>
  66.     <mkdir dir="${deploy.root}/WEB-INF/classes"/>
  67.     <mkdir dir="${deploy.root}/WEB-INF/lib"/>
  68.  
  69.     <copy todir="${deploy.root}">
  70.       <fileset dir="target/web"/>
  71.     </copy>
  72.     <copy todir="${deploy.root}/WEB-INF/classes">
  73.       <fileset dir="target/classes"/>
  74.     </copy>
  75.     <copy todir="${deploy.root}/WEB-INF/lib">
  76.       <fileset dir="lib/core">
  77.         <include name="**/*.jar"/>
  78.       </fileset>
  79.     </copy>
  80.     <copy file="target/web.xml" todir="${deploy.root}/WEB-INF"/>
  81.   </target>
  82. </project>

Creating a launcher

If you want to be able to run the application in hosted mode, you need a launcher. Use this for the purpose - put the following in launch.sh and run chmod +x launch.sh (replace GWT_HOME with the real path to GWT):

PLAIN TEXT
CODE:
  1. #!/bin/sh
  2. APPDIR=`dirname $0`
  3. GWT_HOME=/pack/gwt-linux-1.1.0
  4. CLASSPATH="$GWT_HOME/gwt-user.jar:$GWT_HOME/gwt-dev-linux.jar"
  5. for i in `find . -name '*.jar'`; do
  6.   CLASSPATH="$CLASSPATH:$i"
  7. done
  8. CLASSPATH="$CLASSPATH:bin"
  9. export CLASSPATH
  10.  
  11. MODULE=$1
  12. shitf
  13.  
  14. java com.google.gwt.dev.GWTShell -out $APPDIR/www "$@" $MODULE/${MODULE/*./}.html

When you actually have some code, you can run "./launch.sh dk.contix.gwt.Module" to start the application in hosted mode.

Adding some code

Now it's time to add some code. Start with the entry point class, which should be called Module in thie example:

PLAIN TEXT
CODE:
  1. package dk.contix.gwt.client.Module;
  2.  
  3. import com.google.gwt.core.client.EntryPoint;
  4. import com.google.gwt.user.client.ui.*;
  5.  
  6. /**
  7. * Class description here.
  8. *
  9. * @gwt.module package="dk.contix.gwt" include="shared,client"
  10. */
  11. public class Module implements EntryPoint {
  12.   public void onModuleLoad() {
  13.     final HorizontalPanel p = new HorizontalPanel();
  14.  
  15.     Hyperlink link = new Hyperlink();
  16.     link.setText("Press me");
  17.     link.addClickListener(new ClickListener() {
  18.       public void onClick(Widget sender) {
  19.       }
  20.     }
  21.     p.add(link);
  22.     RootPanel.get().add(p);
  23.   }
  24. }

Deploying

At this point, you should actually be able to compile and deploy this very simple application. First you have to create build.properties in the project root and specify where the application should be deployed, for example

PLAIN TEXT
CODE:
  1. deploy.root=/pack/apache-tomcat-5.5.15/webapps/gwt

Then just execute the following:
ant deploy

And start tomcat. At this point, you should be able to access http://localhost:8080/gwt/dk.contix.gwt.Module/Module.html and see a link on a page. Pressing the link shouldn't do anything.

Adding a service

Now we want to implement a service and call it by clicking the link. First, define the new service:

PLAIN TEXT
CODE:
  1. package dk.contix.gwt.service;
  2.  
  3. /**
  4. * Simple service implementation.
  5. * @gwt.interface service="dk.contix.gwt.shared.ModuleService" path="/moduleService"
  6. */
  7. public class ModuleServiceImpl extends RemoteServiceServlet {
  8.  
  9.   /**
  10.    * @gwt.serviceMethod
  11.    */
  12.   public String getDoubleText(String text) {
  13.     return text + text;
  14.   }
  15. }

The service class should actually implement an interface, but we're going to generate it automaticaly. Do so by executing

PLAIN TEXT
CODE:
  1. ant generate

and refresh the project in Eclipse. At this point, dk.contix.gwt.shared should contain two new interfaces, ModuleService and ModuleServiceAsync. Also, a service factory has been created in dk.contix.gwt.client.
Modify the ModuleServiceImpl class so it implements ModuleService:

PLAIN TEXT
CODE:
  1. public class ModuleServiceImpl extends RemoteServiceServlet implements ModuleService {

Calling services

At this point, we're ready to call the remote service from the client. Modify the ClickListener:

PLAIN TEXT
CODE:
  1. Hyperlink link = new Hyperlink();
  2.     link.setText("Press me");
  3.     link.addClickListener(new ClickListener() {
  4.       public void onClick(Widget sender) {
  5.         ServiceFactory.getModuleService().getDoubleText("testing1", new AsyncCallback() {
  6.           public void onFailure(Throwable caught) {
  7.             p.add(new Label("Error: " + caught.toString()));
  8.           }
  9.  
  10.           public void onSuccess(Object result) {
  11.             String t = (String)result;
  12.             p.add(new Label("Result: " + t));
  13.           }
  14.         });
  15.       }
  16.     }

Deploy the application again. Deploying will automatically generate a new web.xml with a servlet mapping the new service. After restarting Tomcat, you should be able to click the link and get a result back.

That's it

Yes, that's more or less it. The primary reason that it's so easy is the code generation, which means that

  • Modules are automatically created, just annotate EntryPoint classed with @gwt.module
  • Services are configured and interfaces are generated by annotating RemoteServiceServlet classes with @gwt.interface
  • Remote methods are made available when they are annotated with @gwt.serviceMethod
  • Access to the remote services goes through a ServiceFactory, which handles url mapping automatically.

For more complex applications, it's probably not necessary (or desirable) to generate web.xml, so just use it as a starting point. You'll probably add filters and other stuff later.

Have fun!

New version of the GWT Ant compiler task

  • August 12th, 2006
  • 1:19 pm

A new version of the Google Web Toolkit has been released (1.1.0), which means that my Ant task broke. It broke due to some re-organization of classes in the dev jar file, which was fixed without any problems. Worse, however, was the dependency on URLClassLoader deep down in the compiler, which was a problem, as the Ant task created an AntClassLoader, which is not an instance of URLClassLoader. After much fiddling with the classloaders, this problem was also fixed.

No new features have been added, so it should be easy to upgrade - just delete the old ant-gwt.jar and replace it with this new ant-gwt-1.1.0.jar. Documentation is still at

XDoclet module for GWT

  • August 5th, 2006
  • 3:33 pm

Having used Google Web Toolkit to build an application, I found out that I had to write a good portion of code, which might as well be generated automatically. I then decided to mess around with XDoclet a little to see if it was possible to make a new module. It was, and now you can use it too.

Basically, it can generate service interfaces, async services interface, module definitions (.xml.gwt), and a basic web.xml file. Finally, it can create a service factory for creating new Async-objects.

Service interfaces
When creating a remote service, just annotate the class like this:

PLAIN TEXT
CODE:
  1. package dk.contix.gwt.service;
  2.  
  3. /**
  4. * @gwt.interface service="dk.contix.gwt.shared.RemoteService" path="/remoteService"
  5. */
  6. public class RemoteServiceImpl implements RemoteService {
  7.  
  8.   /**
  9.    * @gwt.serviceMethod
  10.    */
  11.   public String getStuff(String what) {
  12.      // code here
  13.   }
  14. }

This will create the interface dk.contix.gwt.shared.RemoteService containing all methods which are annotated with @gwt.serviceMethod. It will also generate the async interface in dk.contix.gwt.shared.RemoteServiceAsync

Modules
To generate module definitions (.gwt.xml files), annotate the EntryPoint classes, like this:

PLAIN TEXT
CODE:
  1. package dk.contix.gwt.client;
  2.  
  3. /**
  4. * @gwt.module package="dk.contix.gwt" include="client,shared"
  5. */
  6. public class Client implements EntryPint {
  7.   // code here
  8. }

This will generate a file in dk/contix/gwt calles Client.gwt.xml. The file will contain the entry-point declaration, all remote servlets, and additional source paths (those specified in the include parameter).

ServiceFactory
If a service factory is generated, a class with static methods for creating instances of the Async interfaces will be created. The factory class will automatically detect url prefixes (if the application is deployed in another context than ROOT).

Generating the files
Create a build.xml file for Ant, if you don't already have one. Include the following target:

PLAIN TEXT
CODE:
  1. <path id="classpath">
  2.   <pathelement location="src"/>
  3.   <pathelement location="${build.dir}/classes"/>
  4.         <fileset dir="lib">
  5.             <include name="**/*.jar"/>
  6.         </fileset>
  7. </path>
  8.  
  9. <target name="generate">
  10.   <taskdef resource="xdoclet/modules/gwt/doclet.xml" classpathref="classpath"/>
  11.  
  12.   <gwtdoclet destdir="src">
  13.     <fileset dir="src">
  14.       <include name="**/*.java"/>
  15.     </fileset>
  16.    
  17.     <interface/>
  18.     <async/>
  19.     <module/>
  20.     <webxml output="web.xml"/>
  21.     <servicefactory class="dk.contix.gwt.client.ServiceFactory"/>
  22.   </gwtdoclet>
  23. </target>

Finallt, place xdoclet-gwt-module-0.1.jar in lib/ so that it becomes a part of the classpath. xdoclet-*.jar and xjavadoc-*.jar is also required. They can be downloaded from xdoclet.sourceforge.net.

Bootstrapping
When a new remote service is created, there's no interface to implement. I work around this simply by annotating the service implementation, generating the code, and then adding the implements declaration.