A small cup of SWT

Summary

Are you interested in developing applications for the Microsoft® Pocket PC? Are you a desktop developer curious about embedded user interfaces? A well-built embedded application is both user and resource friendly. User expectations are high. Resources are very limited...

By Christophe Cornu, IBM OTI Labs
September 19, 2003

Introduction

In the first part of the article, we will list some common UI guidelines that are followed by native Pocket PC applications. We will show how they map to the SWT API. In the second part, we will look at ways to reduce the size of SWT applications. In the last part, we will examine how application startup time can be improved by writing an SWT application using the Connected Limited Device Configuration (CLDC) Java™ profile.

UI guidelines for the Pocket PC

Application bringing up a File dialog box

 

import org.eclipse.swt.*;
import org.eclipse.swt.widgets.*;

public class FileDialogMain {

public static void main(String[] args) {
	Display display = new Display();
	Shell shell = new Shell(display);
	shell.setText("Main");
	Menu menu = new Menu(shell, SWT.BAR);
	shell.setMenuBar(menu);
	shell.open();
	FileDialog dialog = new FileDialog(shell, SWT.OPEN);
	String name = dialog.open();
	if (name != null) shell.setText(name);
	while (!shell.isDisposed()) {
		if (!display.readAndDispatch())
			display.sleep();
	}
	display.dispose();
}
}

Dialog-based application

import org.eclipse.swt.*;
import org.eclipse.swt.widgets.*;

public class OkButton {

public static void main(String[] args) {
	Display display = new Display();
	Shell shell = new Shell(display, SWT.CLOSE);
	shell.setText("Main");
	Menu menu = new Menu(shell, SWT.BAR);
	shell.setMenuBar(menu);
	shell.addListener(SWT.Close, new Listener() {
		public void handleEvent(Event e) {
			System.out.println("Ok button tapped");
		}
	});
	shell.open();
	while (!shell.isDisposed()) {
		if (!display.readAndDispatch())
			display.sleep();
	}
	display.dispose();
}
}

Application resizing when the virtual keyboard shows up

Figure 4 - Input panel hidden

Figure 5 - Input panel visible

import org.eclipse.swt.*;
import org.eclipse.swt.widgets.*;
import org.eclipse.swt.layout.*;

public class SipResize {

public static void main(String[] args) {
	Display display = new Display();
	Shell shell = new Shell(display, SWT.RESIZE);
	shell.setLayout(new FillLayout());
	shell.setText("Main");
	Menu mb = new Menu(shell, SWT.BAR);
	shell.setMenuBar(mb);
	Text text = new Text(shell, SWT.MULTI | SWT.V_SCROLL);
	String buffer = "";
	for (int i = 0; i < 100; i++) {
		buffer += "This is line " + i + "\r\n";
	}
	text.setText(buffer);
	shell.open();
	while (!shell.isDisposed()) {
		if (!display.readAndDispatch())
			display.sleep();
	}
	display.dispose();
}
}

1. The user must be able to input data with the input panel - every time the application requires text entry. The input panel should not hide text widgets. The first solution is to layout text widgets in the first part of the screen. The second solution is to resize the window when the input panel is turned on - by using the shell style SWT.RESIZE, as shown in the sample above.
2. The application should restore the input panel to the state the user left it in the last time this application was used. This state is automatically restored by SWT and requires no particular application handling.

Application using a pop-up menu

Figure 6 - Stylus hold animation on Pocket PC 2002

Figure 7 - Pop-up menu activated

import org.eclipse.swt.*;
import org.eclipse.swt.widgets.*;

public class StylusHold {

public static void main(String[] args) {
	Display display = new Display();
	Shell shell = new Shell(display);
	shell.setText("Main");
	Menu mb = new Menu(shell, SWT.BAR);
	shell.setMenuBar(mb);
	Menu menu = new Menu(shell, SWT.POP_UP);
	MenuItem item = new MenuItem(menu, SWT.CASCADE);
	item.setText("item 1");
	MenuItem item2 = new MenuItem(menu, SWT.CASCADE);
	item2.setText("item 2");
	shell.setMenu(menu);
	shell.open();
	while (!shell.isDisposed()) {
		if (!display.readAndDispatch())
			display.sleep();
	}
	display.dispose();
}
}

Memory and size

Size of different SWT configurations

Structure of the SWT API

• org.eclipse.swt (constants)
• org.eclipse.swt.widgets (native widgets)
• org.eclipse.swt.events (event listeners)
• org.eclipse.swt.graphics (graphics drawing, image decoders)
• org.eclipse.swt.layout (layouts)
• org.eclipse.swt.dnd (drag and drop)
• org.eclipse.swt.ole (ole)
• org.eclipse.swt.accessibility (accessibility)
• org.eclipse.swt.custom (custom widgets)
• org.eclipse.swt.printing (printing)
• org.eclipse.swt.program (registry)

• org.eclipse.swt
• org.eclipse.swt.widgets
• org.eclipse.swt.events
• org.eclipse.swt.graphics
• org.eclipse.swt.layout

Tips to reduce the size of the SWT library

1. Import the two projects org.eclipse.swt and org.eclipse.swt.win32.wce_ppc.arm into your Eclipse workspace.
2. Locate the Ant script build_custom.xml. This file is located in the project org.eclipse.swt.win32.wce_ppc.arm.
3. Run this Ant script from within Eclipse. Modify the default Property targets according to the SWT API you require. The Ant script outputs the custom SWT jar to the folder org.eclipse.swt.win32.wce_ppc.arm/ws/win32.

Figure 9 - Ant script used to build a custom SWT jar

Exclude Debug Information

Exclude Custom Widgets

Exclude Accessibility and DND

Exclude Image Decoders

Exclude Layouts

Use J2ME

To go further

• Unused SWT classes can simply be removed. For example, the class org.eclipse.swt.widgets.Tree can be removed if the SWT application is not using the tree widget. SWT is mostly implemented in Java. A tool - an obfuscator for example - can be used to exclude unused SWT classes.
• Removing unused JNI OS calls can reduce the size of the native SWT library. Each JNI call is wrapped with a preprocessor directive #ifndef OS_METHODNAME. Special tools can determine which SWT native methods are not referenced through all possible execution paths of a particular SWT application. This information is used to build a header file with a list of native methods to exclude. A sample header file defines.h is available in the org.eclipse.swt project under the folder "Eclipse SWT PI"/win32/library.

Startup time

import org.eclipse.swt.widgets.*;

public class MyApp {

static {
	connectDataBase();
}

public static void main(String argv[]) {
	Display display = new Display();
	Shell shell = new Shell(display);
	shell.setText("MyApp");
	shell.open();
	while (!shell.isDisposed()) {
	if (!display.readAndDispatch())
		display.sleep();
	}
	closeDataBase();
	display.dispose();
}

static void connectDataBase() {
	try {
		Thread.sleep(5000);
	} catch (Exception e) {}
}

static void closeDataBase() {
	try {
		Thread.sleep(5000);
	} catch (Exception e) {}
}
}

Reduce application code on startup

• Invoke as few application classes as possible so that the JVM’s classloader does not have to resolve them on startup. If your main class inherits from a deep hierarchy, all the super classes must be resolved and initialized before the Main method actually gets to run.
• Review each of your class initializers. Lengthy operations should not take place inside class initializers. Class initializers are often used to load resources and native libraries. This common Java idiom may cause here an unacceptable startup time.

import org.eclipse.swt.*;
import org.eclipse.swt.layout.*;
import org.eclipse.swt.widgets.*;

public class MyApp {

public static void main(String argv[]) {
	Display display = new Display();
	Shell shell = new Shell(display);
	shell.setText("MyApp");
	shell.setLayout(new FillLayout());
	final Button button = new Button(shell, SWT.PUSH);
	button.setText("Connect");
	button.addListener(SWT.Selection, new Listener() {
		public void handleEvent(Event e) {
			button.setText("Connecting");
			connectDataBase();
			button.setText("Connected");
		}
	});
	shell.open();
	while (!shell.isDisposed()) {
		if (!display.readAndDispatch())
			display.sleep();
	}
	closeDataBase();
	display.dispose();
}

static void connectDataBase() {
	try {
		Thread.sleep(5000);
	} catch (Exception e) {}}

static void closeDataBase() {
	try {
		Thread.sleep(5000);
	} catch (Exception e) {}
}
}

Diagnose if an application runs too much initialization code

static long start = System.currentTimeMillis();

long end = System.currentTimeMillis();
System.out.println("User init time: " + (end - start));

Reduce Java library code initialization on startup

Startup time – J2SE

Startup time – J2ME CLDC

-jcl:cldc:loadlibrary=swt-win32-3002

Figure 10 - Number of classes loaded (J2SE versus CLDC)

• User initialization code executed before the SWT event loop is executed.
• The type of Java profile. A lightweight profile (which requires fewer core classes) is preferable. SWT for the Pocket PC can be used against the J2ME CLDC profile.

Conclusion

Quick reference

SWT FAQ - What do I need to do to run SWT on the PocketPC?
SWT FAQ - Where is the SWT library for the PocketPC?

IBM is a registered trademark of International Business Machines Corporation in the United States, other countries, or both.

Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.

Microsoft and Windows are registered trademarks of Microsoft Corporation in the United States, other countries, or both.

Other company, product, and service names may be trademarks or service marks of others.