The quick fix:
Going through the iBatis docs can sometimes be tedious.  Fortunately, the solution is simple.  If you open your xml file dealing with the object in question, and go to your resultMap element for the class, you’ll typically have a result element for each column you’re dealing with.  Add an attribute called nullValue with a value to give the object in question in case a NULL is present.  It’s that simple. 

Here’s an example…
You have a table called Employee with several columns and create a POJO like below to hold that data:

public class Employee {
    private int id;
    private String login;
    private String password;
    private int authorityType;
    private boolean passwordExpired;
 
    // ... constructors and setter/getter methods here...
}

Let’s say that authorityType and passwordExpired were NULL values in the database.  Adding the nullValue attribute to the xml file like so would solve your issue:

<resultMap id="EmployeeResult" class="Employee">
  <result property="id"              column="id"                               />
  <result property="login"           column="login"                            />
  <result property="password"        column="password"                         />
  <result property="authorityType"   column="authorityType"   nullValue="1"    />
  <result property="passwordExpired" column="passwordExpired" nullValue="false"/>
</resultMap>

Creating your certificate

• Go to your JRE bin folder and there will be a file called “keytool”.
• Type keytool -genkey -alias tomcat -keyalg RSA -keystore c:/.keystore The “keystore” parameter is optional.  It’s the location where the certificate keystore will be stored.  By default it will be stored in the current user’s home directory.
• Upon executing, you will be prompted with a number of questions like name, location, organization, etc.  For name I recommend using the domain or if need be the machine name.

Modifying the server.xml file

• Locate the server.xml in $CATALINA_HOME/conf/server.xml
• Open it and look for a section dealing with the SSL Connector.  The section will look something like this:

<-- Define a SSL Coyote HTTP/1.1 Connector on port 8443 -->
<!--
<Connector 
           port="8443" minProcessors="5" maxProcessors="75"
           enableLookups="true" disableUploadTimeout="true"
           acceptCount="100" debug="0" scheme="https" secure="true";
           clientAuth="false" sslProtocol="TLS"/>
-->

• Uncomment the block, and add in another attribute for the keystore location.  We’ll add in keystoreFile=”c:\.keystore”, so when finished we’ll have:

<-- Define a SSL Coyote HTTP/1.1 Connector on port 8443 -->
<Connector 
           port="8443" minProcessors="5" maxProcessors="75"
           enableLookups="true" disableUploadTimeout="true"
           acceptCount="100" debug="0" scheme="https" secure="true";
           clientAuth="false" sslProtocol="TLS" keystoreFile="c:\.keystore">
</Connector>

For full workings of server.xml refer to the apache site.

Last step is to restart Tomcat and point the browser to:
https://localhost:8443
Remember the https and it uses port 8443 by default which can be changed in the server.xml

Anyway, enough with the blabbing.  I’ve put together a simple example to add a right click context menu and override the default browser context menu using GWT. 

In the box below you can try it out, right-click in there and you can demo it.

In case the iframe doesn’t show up in your browser you can see and try the example here.
Now here’s how it’s done.

I used a DeckPanel to switch between several panels. The popup context menu is used to choose.  To allow the DeckPanel to catch the right-click event (and you can also listen for double-clicks and several other things) I extended the DeckPanel.   For simplicity I added “Adv” (Advanced) in front of the several classes I’ve extended so this one will be AdvDeckPanel.  The first thing to do in the constructor is add sinkEvents(). Then we’ll override onBrowserEvent() in the class.  Here’s the code:

public AdvDeckPanel() {
  super();
  sinkEvents(Event.ONMOUSEUP | Event.ONDBLCLICK | Event.ONCONTEXTMENU);
}
 
public void onBrowserEvent(Event event) {
  GWT.log("onBrowserEvent", null);
  event.cancelBubble(true);//This will stop the event from being propagated
  event.preventDefault();
  switch (DOM.eventGetType(event)) {
    case Event.ONMOUSEUP:
      if (DOM.eventGetButton(event) == Event.BUTTON_LEFT) {
        GWT.log("Event.BUTTON_LEFT", null);
        listener.onClick(this, event);
      }
 
      if (DOM.eventGetButton(event) == Event.BUTTON_RIGHT) {
        GWT.log("Event.BUTTON_RIGHT", null);
        listener.onRightClick(this, event);
      }
      break;
    case Event.ONDBLCLICK:
      break;
 
    case Event.ONCONTEXTMENU:
      GWT.log("Event.ONCONTEXTMENU", null);
      break;
 
    default:
      break; // Do nothing
  }//end switch
}

Notice the two lines in onBrowserEvent():
event.cancelBubble(true);
event.preventDefault();

These are the two lines that tell the browser not to show it’s default context popup menu. Also note that overriding the default context menu doesn’t work in all browsers, I’m not sure if this is a bug in GWT. If you’re using firefox then you’ll have no problems, with IE you may need to add the following to your html:

<body oncontextmenu="return false;">

Other than that there’s just a switch statement that checks the event type, in this case we’re interested with ONMOUSEUP, and we’ll call the listener’s onClick() or onRightClick() based on the Event’s fields.

AdvDeckPanel also has a reference to AdvClickListener which looks like:

public interface AdvClickListener extends ClickListener {
  void onClick(Widget sender, Event event);
  void onRightClick(Widget sender, Event event);
}

This reference is basically the same as ClickListener, but has a separate method to handle the right-click.  I also pass the Event object so I can get the x and y from the click so the context menu shows up at that location instead of the top-left of the screen.

AdvDeckPanel implements AdvClickNotifier which does the same thing as GWT’s SourcesClickEvents interface, but handles the AdvClickListener instead.

public interface AdvClickNotifier {
  public void addClickListener(AdvClickListener listener);
  public void removeClickListener(AdvClickListener listener);
}

So, once you have your widget (in this case the AdvDeckPanel) and the listeners set up to handle the right-click, then we add in the code to build the popup menu and commands that go with it.  I put all of this in the EntryPoint.  I have three widgets (panels) and a Command for each like this:

private AdvDeckPanel deckPanel = new AdvDeckPanel();
final private PopupPanel popupPanel = new PopupPanel(true);
private VerticalPanel defaultPanel = new VerticalPanel();
private SimplePanel imagePanel = new SimplePanel();
private SimplePanel sponserPanel = new SimplePanel();
 
Command showAlertCommand = new Command() {
  public void execute() {
    deckPanel.showWidget(0);
    popupPanel.hide();
    Window.alert("Hope this example helps.");
  }
};
 
Command showImageCommand = new Command() {
  public void execute() {
    deckPanel.showWidget(1);
    popupPanel.hide();
  }
};
 
Command showSponserCommand = new Command() {
  public void execute() {
    deckPanel.showWidget(2);
    popupPanel.hide();
  }
};

A Command is called when the MenuItem is clicked.

Now the code to build the menu, link the commands, and handle the right-click:

private void createPopupMenu() {
  MenuBar popupMenuBar = new MenuBar(true);
  MenuItem alertItem = new MenuItem("Show alert", true, showAlertCommand);
  MenuItem imageItem = new MenuItem("Show Oliver ", true, showImageCommand);
  MenuItem sponserItem = new MenuItem("Show sponser ", true, showSponserCommand);
 
  popupPanel.setStyleName("popup");
  alertItem.addStyleName("popup-item");
  imageItem.addStyleName("popup-item");
  sponserItem.addStyleName("popup-item");
 
  popupMenuBar.addItem(alertItem);
  popupMenuBar.addItem(imageItem);
  popupMenuBar.addItem(sponserItem);
 
  popupMenuBar.setVisible(true);
  popupPanel.add(popupMenuBar);
}
 
public void onRightClick(Widget sender, Event event) {
  int x = DOM.eventGetClientX(event);
  int y = DOM.eventGetClientY(event);
  popupPanel.setPopupPosition(x, y);
  popupPanel.show();
}

Lastly, to make the menu actually look like a popup menu I modified the CSS like so:

.popup {
  background-color: gray;
  border-color: gray gray gray gray;
  border-width: 1px 3px 3px 1px;
  border-style: solid solid solid solid;
}
 
.popup-item {
  font-weight: normal;
  font-size: 80%;
}

What this does is makes it so the border isn’t the thick default GWT blue, and uses a thin border with the right and bottom borders a bit thicker.  This gives the popup that shadowed look.

A couple of books worth checking out are: GWT in Actionand GWT in Practice
Here’s the source and more links.

In case the iframe doesn’t show up in your browser you can see and try the example here.

First, let me explain how it’s all done.  Using a list of colors, in this case different shades of yellow, you add and remove styles (a color) of a widget.  The colors are stored in the CSS file.  The change is triggered by a timer.  The YellowFadeHandler class has an inner class called FadeObject which holds a color and a com.google.gwt.user.client.ui.UIObject. This UIObject is the super class of all major GWT widgets and has the methods:

addStyleName(java.lang.String style)
and
removeStyleName(java.lang.String style)

The FadeObject class

private class FadeObject {
	private UIObject uiObj = null;
	private int color = 0;
 
	public FadeObject(UIObject uiObj) {
		this.uiObj = uiObj;
		this.uiObj.addStyleName(yftStyles[color]);
	}
 
	public void nextColor() {
		if (color == transparent_color) return;
		uiObj.removeStyleName(yftStyles[color]);
		color++;
		uiObj.addStyleName(yftStyles[color]);
	}
	public int getColor() {
		return color;
	}
	public boolean isTransparent() {
		if (color == transparent_color) return true;
		return false;
	}
}// end class FadeObject

The YellowFadeHandler class

  private List<FadeObject> fadeObjectList = new LinkedList<FadeObject>();
 
  public YellowFadeHandler() {
    Timer t = new Timer() {
      public void run() {
        if (fadeObjectList.isEmpty()) return;
        for (Iterator<FadeObject> iter = fadeObjectList.iterator(); iter.hasNext(); ) {
          FadeObject fObj = iter.next();
          fObj.nextColor();
          if (fObj.isTransparent()) {
            //if it hits the transparent color then fading is done so remove it.
            iter.remove();
            GWT.log("fade object removed", null);
            continue;
          }
        }
      }
    };
    t.scheduleRepeating(120);
  }
 
  public void add(UIObject obj) {
    if (obj == null) return;
    FadeObject fo = new FadeObject(obj);
    fadeObjectList.add(0, fo);
    GWT.log("fade object added", null);
  }

My YellowFadeHandler class holds a List of these FadeObjects.  When the timer fires, it iterates through the list and changes (removes the old and adds the new) styles of the widgets.  When the style is changed to the last color in the chain (transparent), the widget is then removed from the list.  So to have a widget go through the yellow fade, all that needs to be done is call handler.add(widget);
Super simple. Here’s the source.
A couple of books worth checking out are: GWT in Actionand GWT in Practice

I needed to use JSNI recently.  Since GWT doesn’t provide a way to bring the browser to the front or top like javascript does with it’s self.focus(); I was able to use JSNI to call that line of javascript.  Here’s a quick example:

public static native void bringToFront() /*-{
  self.focus();
}-*/;

Then all you need to do is call the bringToFront() method like you normally would.  Along with noticing in the native keyword, you’ll immediate see that the block looks commented out.  JSNI has two tokens to mark the beginning and end of your javascript the /*-{ marks the begin and }-*/ marks the end.  Everything in between those tokens are assumed to be javascript.

There are more examples on GWT JSNI site.

• gchart is 100% GWT (meaning it’s not a javascript wrapper)
• It runs on the client-side. Some other charting APIs actually build the chart on the server-side as an image and return the link for the image.  This can be an advantage for some situations, so you may need to think about if you want a client-side or server-side render.
• Open source under Apache License, Version 2.0
• Very simple to use.

I put together a very simple example, and it shows how quickly you can build a chart.  The example is a compound interest financial calculator shown below (go ahead and try it out).  It has a few fields to enter your initial amount, annual contributions, interest rate, number of compounds per year and the number of years.  After clicking on the calculate button it will show your future amount and chart it.

In case the iframe doesn’t show up in your browser you can see and try the charting example here.

The simplicity of this charting API is the fact that the charts are GWT widgets.  Here’s the code for my compounding interest chart:

public class AmountChart extends GChart {
	public AmountChart() {
		setChartSize(240, 200);
		setPadding("4px");
		getXAxis().setAxisLabel("Years");
		getYAxis().setAxisLabel("$");
	}
 
	public void addPoint(double x, double y) {
		GWT.log("point added ("+x+", "+y+")", null );
		getCurve().addPoint(x, y);
	}
}

Then all I did was add it to the DecoratedTabPanel, put in the event listeners, the formula (which I got from wiki) and done.
You can download the full source here, and the entire application is client side.

Updated 2008-01-28: I updated the iframe that the form is in to be more friendly with IE. Also made a change recommended by John Gunther to remedy a problem with IE. Compiled using gchart 2.4 and I updated the downloadable source.

There are four things we’ll need to accomplish:
1. Place the log4j.properties file
2. Write a servlet that will initialize the logger.
3. Modify the web.xml file.
4. Modify the GWT -shell and -compile scripts.

1. Place the log4j.properties file

Under <gwt-project>/tomcat/webapps/ROOT/WEB-INF/ create a “classes” dir.  The “classes” dir is where you put the log4j.properties file.  Here’s the log4j.properties file I’m using:
log4j.rootCategory=DEBUG, dest1, dest3

! Log to the console
log4j.appender.dest1=org.apache.log4j.ConsoleAppender
log4j.appender.dest1.layout=org.apache.log4j.PatternLayout
log4j.appender.dest1.layout.ConversionPattern=%-5p %d{HH:mm:ss.SSS} [%-15.15t] [%-25.25c{1}] %m%n

! LOG TO A FILE
log4j.appender.dest3=org.apache.log4j.RollingFileAppender
log4j.appender.dest3.layout=org.apache.log4j.PatternLayout
log4j.appender.dest3.layout.ConversionPattern=%-5p %d{EEE MMM dd HH:mm:ss.SSS zzz yyyy} [%-15.15t] [%-25.25c{1}] %m%n

! Specify the file name
log4j.appender.dest3.File=./logs/hosted-log4j.log

! Control the maximum log file size
log4j.appender.dest3.MaxFileSize=3000KB
log4j.appender.dest3.MaxBackupIndex=3

2. Write a servlet that will initialize the logger.

Next you’ll want to have a servlet that will load the properties file and init the logger. This file (Log4JInitServlet.java) will go in the <gwt-project>/src/ dir.

package com.nick.example.server;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
/**
* Log4JInitServlet
*
* This class should get loaded first (based on the web.xml),
* so it can init the logger.
*
* @author Nick
*/
public class Log4JInitServlet extends HttpServlet {
  static final Logger logger = Logger.getLogger(Log4JInitServlet.class);
 
  public void init() throws ServletException {
    System.out.println("Log4JInitServlet init() starting.");
    String log4jfile = getInitParameter("log4j-properties");
    System.out.println("log4jfile: "+log4jfile);
    if (log4jfile != null) {
      String propertiesFilename = getServletContext().getRealPath(log4jfile);
      PropertyConfigurator.configure(propertiesFilename);
      logger.info("logger configured.");
    }else{
      System.out.println("Error setting up logger.");
    }
      System.out.println("Log4JInitServlet init() done.");
  }
}

This servlet should be loaded first, which can be accomplished by modifying the web.xml file.

3. Modify the web.xml file.

This file is located in <gwt-project>/tomcat/webapps/ROOT/WEB-INF/
My web.xml file looks like:

<?xml version="1.0" encoding="UTF-8"?>
<web-app>
  <servlet>
    <servlet-name>Log4JInitServlet</servlet-name>
    <servlet-class>com.nick.example.server.Log4JInitServlet</servlet-class>
    <init-param>
      <param-name>log4j-properties</param-name>
      <param-value>/WEB-INF/classes/log4j.properties</param-value>
     </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet>
    <servlet-name>shell</servlet-name>
    <servlet-class>com.google.gwt.dev.shell.GWTShellServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>shell</servlet-name>
    <url-pattern>/*</url-pattern>
  </servlet-mapping>
</web-app>

Notice the line <load-on-startup>1</load-on-startup>, which tells tomcat to load the Log4JInitServlet first.

4. Modify the GWT -shell and -compile scripts.

Modify your gwt –shell and –compile files to add the log4j jar into the class path. Here’s my <project>-shell.cmd file. Take note of the log4j jar that I added.

[Windows]
@java -Xmx256M -cp “%~dp0\src;%~dp0\bin;C:/lib/gwt-windows-1.5.3/gwt-user.jar;C:/lib/gwt-windows-1.5.3/gwt-dev-windows.jar;C:/lib/gwt-windows-1.5.3/log4j-1.2.12.jar” com.google.gwt.dev.GWTShell -out “%~dp0\www” %* com.nick.example.HostedLog4j/HostedLog4j.html

[linux]
#!/bin/sh
APPDIR=`dirname $0`;
java -Xmx256M -cp “$APPDIR/src:$APPDIR/bin:$HOME/projects/gwt-linux-1.5.3/gwt-user.jar:$HOME/projects/gwt-linux-1.5.3/gwt-dev-linux.jar:$HOME/projects/lib/log4j-1.2.15.jar” com.google.gwt.dev.GWTShell -out “$APPDIR/www” “$@” com.nick.example.HostedLog4j/HostedLog4j.html;

Make sure to change the <project>-compile.cmd in the same way.
You can then run your <gwt-project>-shell.cmd and the logger should work. It will create a log directory in under <gwt-project> and place your log file inside there.

In trying to make a decision on whether to go GWT-Ext or Ext-GWT I’ve done some reading including the websites of those two technologies, forums, and various blogs like:

http://www.gwtsite.com/top-5-gwt-libraries/
http://roberthanson.blogspot.com/2008/04/gwt-ext-vs-ext-gwt.html
http://ajaxian.com/archives/to-gwt-ext-or-to-ext-gwt

The most talked about topic when discussing this comparison seems to be licensing, but I don’t want to spend much time on that.  Instead of comparing the two technologies line by line, I take a small existing vanilla GWT application and add new needed functionality such as drag and drop, resizable columns, sortable columns, and additional layouts.  This was done first using GWT-Ext and then again using Ext-GWT.  The opinions I gather are based on coding with both over a few days.

GWT-Ext Experience

This was actually my second choice, and became my first choice based on comparing the licenses of the two.  My first steps were changing out widgets used and hoping that the underlying code dealing with the model wouldn’t need to be modified (much).  Layouts are one thing I noticed that are considerably different.  Instead of using VerticalPanel or HorizontalPanel, you use a Panel and add a modifier to make it flow vertical or horizontal, much like Swing.  While this is good if you know Swing, and are starting the app from scratch, it can be a pain if converting like i am.

Another difference when dealing with going vanilla GWT to GWT-Ext was rewriting code that handles FlexTable or GridPanel updates or, in other words, the way you get data into the table.  In GWT land, you can treat the FlexTable as the data, much like a two-dim array, and set data to the cells.  GWT-Ext uses something called a Store, which is basically the data itself.  When you add to the Store, the GridPanel gets updated.  There are pros and cons to both methods I suppose, but that’s another discussion.  I will say the reason I stopped using GWT-Ext was because of problems rendering the grid to the screen when using the GridPanel with certain layouts.  I suspected this was due to it being a js wrapper.  It turned out there was a known bug which required a workaround just to get the grid to show.  After spending many hours dealing with this problem and a few others I decided I shouldn’t be wasting my time with something that has problems taking one panel and adding it to another like panel.add(grid).  In GUI building, an operation like that is simple and frequent.

On to Ext-GWT

Last thing I wanted to do was revert back and start again, but here it goes.

One big difference between the two Exts is that GWT-Ext is just javascript wrapper.  It’s visible while configuring because you’ll add scripts and javascript libraries to your public folder.  With Ext-GWT none of that needed to be done.  This is because Ext-GWT is a GWT library and doesn’t wrap javascript.  I like this.

So I start again changing out widgets, and notice that there’s almost no work to be done.  The new widgets use same function calls as old ones.  They did drop the ball on the Button class and it’s listener (actually, I don’t like the way events are coded).  Not sure why you would not stick with a ClickListener and onClick()….but whatever.   The layouts are similar, and they include VerticalPanel as well.  Changing the FlexTable out for the Grid took some work, but less than GWT-Ext.  It does use a StoreList (similar to GWT-Ext’s Store) but I felt it made a little more sense.  There was little time spent correcting column sizes and dealing with autofills, which makes me happy, and there were no issues getting the Grid to show up.

Final Decision

Well, everything was fine but another day has passed and I’m just not 100% happy with Ext-GWT.  Running the hosted browser and compiling has become slower than ever (still faster than GWT-Ext though).  I got to thinking and realized that the only enhanced component I really needed was the Grid over the FlexTable, and I did get the grid setup just like I wanted.  Since one of the things I really hated about Ext-GWT was the event handling code, I asked myself: Do I really need to have all of my buttons, checkboxes, panels, etc in Ext-GWT?  Can’t I just use the fancy Grid and then make everything else using vanilla GWT?  I decided to try this, and not only did it work perfectly, but there was noticably lower load times and increased speed.

My final take is, use vanilla GWT for events and where you can use it.  For GWT components that are missing features you need use Ext-GWT.

The EchoServer will open a listen socket on port 4444.  Compile it, run it and then to test it you can open a command prompt and type telnet localhost 4444

import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
 
/**
 * @author NickC
 */
public class EchoServer {
   private static final int BUFFER_SIZE = 256; 
   private static int listenPort = 4444;
 
   public static void main(String[] args) throws Exception{
      ServerSocket serverSock = new ServerSocket(listenPort);
      System.out.println("listening on port "+listenPort);
      Socket sock = serverSock.accept();
      System.out.println("new connection " + sock);
 
      InputStream sockIn = sock.getInputStream();
      OutputStream sockOut = sock.getOutputStream();
      byte[] buffer = new byte[BUFFER_SIZE];
      while(true) {
         Thread.sleep(50);
         int count = 0;
         if ((count = sockIn.available()) > 0) {
            if (count >= buffer.length) {
               count = buffer.length;
            }
            count =  sockIn.read(buffer, 0, count);
            System.out.println("echoing "+count+" bytes");
            sockOut.write(buffer, 0, count);
            sockOut.flush();
         }
      }
   }
}

Source in a file: EchoServer.java

I started with a simple problem and it turns out there’s a simple solution.

My problem:
In the current application I’m coding I display user data (like many apps).  Included with the user data, the page also shows the user’s photo.  The problem was that the photos were stored in a directory external to Tomcat (D:\photos) and I need to get my webapp access to that directory and have those photos in Tomcat’s path.

My Solution:
To solve this I needed to add what Apache calls a context path which can be done by adding an xml file.

Here’s a bit of given information so this is easier to follow.

• I’m using Tomcat 5.5
• The name of my webapp is called MyProject which is located at $CATALINA_HOME/webapps/MyProject
• The directory I’m trying to add to Tomcat’s path is “D:\photos“
• I want my photos to be accessible in the path $CATALINA_HOME/webapps/MyProject/photos (or http://localhost:8080/MyProject/photos).

Creating the context file:

• In $CATALINA_HOME/conf/[enginename]/[hostname]/ (in my case $CATALINA_HOME/conf/Catalina/localhost/) create a file called “MyProject#photos.xml“.  The value before the # is your webapp name and the value after is the path you want added.
• In this file add: <Context docBase=”d:\photos” /> and save.
• Restart Tomcat.

Note for GWT:  I can’t seem to get this working with the embedded Tomcat that comes with GWT.  If anyone knows a simply way, please let me know.  In the mean time I’m using full Tomcat with the noserver option, and for the name of my context file I’m putting the full package name.  For example: com.nick.MyProject#photos.xml