Getting started with SWT

Basic window population

The minimum required code to get a main window to appear

	Display display = new Display();

	Shell shell = new Shell(display);
	shell.open ();
	while (!shell.isDisposed ()) {
		if (!display.readAndDispatch ()) display.sleep (); 
	} 
	display.dispose ();

The interplay between the Display and Shell indicate a close relationship between the underlying Operating System and the Application Window in this most basic SWT application. Each Control you wish to place in the application window is passed a reference to the shell in its constructor.

Button button = new Button (shell, SWT.PUSH);

GridPuzzle gets a layout

While it is easy enough to add Controls to the display, the Layout classes are essential to getting the controls to display in an orderly fashion. For the GridPuzzle the requirement was to display more or less square buttons in a 4 by 4 grid. This code is all that's necessary to achieve the grid look:

		GridLayout gridLayout = new GridLayout();
		gridLayout.numColumns = 4;
		gridLayout.verticalSpacing=0;
		gridLayout.horizontalSpacing=0;
		shell.setLayout(gridLayout);

Easy enough... However as you add these buttons to the Shell, you discover that their width and height are defined primarily by their captions. Efforts to call the setSize() method of the Button appear to have no affect and the result is a misshapen hodge podge of buttons.

The answer for the layout is to pass a GridData object to the Button's setLayout() method.

	button.setLayoutData(new GridData(GridData.FILL_BOTH));

Since there are 16 buttons, I figured for the sake of saving resources, I would reuse a single GridData object for the entire 16. However, this doesn't work! You need to pass a new object to each button.

for (int i = 0; i < 16; i++){
	Button button = new Button (shell, SWT.PUSH);
	button.setFont( font);
	button.setText( this.getRandomCaption(i) );
	if (button.getText().equals("0")) button.setText("");
	button.addSelectionListener( this);
	button.setLayoutData(new GridData(GridData.FILL_BOTH));
	button.pack();
	buttons[i]=button;
}

The GridData class is designed to allow alignment and fill specifications within the Grid. You can either pass these in the constructor

new GridData(GridData.HORIZONTAL_ALIGN_FILL | GridData.GRAB_HORIZONTAL);

or you can define them through public fields:

     	GridData gridData = new GridData();
	gridData.horizontalAlignment = GridData.END; //right-aligned effect
        gridData.grabExcessHorizontalSpace = true;   //expand on window resize
        button.setLayoutData(gridData);

Some nasty things about fonts

I really wanted to make the Button captions a little more readable by increasing the size of its font. Delving into the SWT Javadocs (which are, by the way, very well put together... and, with the current state of SWT information, you tend to spend a lot of time in the Javadocs), you discover two things about fonts:

To tie the whole thing together, you can start with this code:

	//create a larger font for the buttons
	FontData[] fd = shell.getFont().getFontData();
		
	for (int i = 0; i < fd.length; i++) {
		fd[i].setHeight(16);
	}

	Font font = new Font(display,fd);

Then later on, you set it for each Button in the Grid.

button.setFont( font);

Unlike the GridData class and mercifully for System resources, you can pass the same font object into each of the 16 buttons.

Event Model...a pleasant surprise

Sometimes coding in SWT seems like a total departure from either Swing or AWT. But the Event model is surprisingly close to AWT. You define Listeners and you add these listeners to each Control that captures user (or other actor) activities in the form of clicks, keypresses and so on.

Although most of the SWT examples define Listeners as inner classes, I opted for the old Swing trick of making the Main class implement one of the Listener interfaces. In this case, the Listener I used was SelectionListener. In Swing, the JButton class will add an ActionListener, but the differences between Swing and SWT end there.

Like Swing, there is an Adapter class -- SelectionAdapter -- that provides a "do nothing" implementation. You can subclass SelectionAdapter and implement any of the two methods it defines. However, since SelectionListener defines only two methods -- and partly because I wasn't sure which of the two to implement -- I decided to implement SelectionListener in the GridPuzzle class.

It didn't take long to figure out that when I clicked on a button, the event that fired off was widgetSelected()

public void widgetSelected(SelectionEvent event){
	if (event.getSource().getClass().equals(Button.class)){
		Button button = (Button) event.getSource();
		if (button.getText().equals("") ){
			Toolkit.getDefaultToolkit().beep();
		} else {
			this.swapPlaces(((Integer) button.getData()).intValue());	
		}
	}		
}	
	
public void widgetDefaultSelected(SelectionEvent event){
	System.out.println("Widget was defaultselected: " + event.getSource());	
}

The mechanics of getting at the cause of the event remains just as in Swing. You make a call to the event's getSource() method, normally casting it to the preferred Control, and you are in business. In the code above, I was trying to beep, if someone clicked on a captionless Button, or swap places with any adjacent, blank-captioned button.

Concluding comments

I'm kind of impressed with SWT from the point of view of its speed and relative ease of development. I could remark that after 15 years, GUI programming seems to have gotten more difficult, not easier... but that would be complaining. One thing that really impresses me about SWT is that there may be an opportunity for some of us Java gurus to take a break from coding on the server and migrate to client side. Wouldn't that be a switch?

Resources

I'm going to provide some good resources here, but you need to remember that, at the moment, SWT isn't the most widely- documented technology. For all the thousands of pages on Javascript and Jsps, you'd thing it would be easy to find something about something as interesting as SWT. Happy googling!