So how would you do this? The first solution that came to mine is depth-first traversal of the tree. This method could be adapted to any tree structure in just about any language.

We need a callback function for everytime we ‘hit’ a tree node. Let’s create an interface called ‘Action’:
Action.java:

public interface Action<T> {
	public void execute(T object);
}

Now, we need to create a file called TreeItemUtil.java. This will include the algorithm. The algorithm is really straightforward, it just uses a stack for each node and iterates the stack. If a node has children, they are pushed onto the stack.
TreeItemUtil.java:

public class TreeItemUtil {
	
	public static Collection<TreeItem> fetchChildren(TreeItem ti){
		List<TreeItem> children = new ArrayList<TreeItem>();
		
		for (int i = 0; i < ti.getChildCount(); ++i)
			children.add(ti.getChild(i));
		return children;
	}
	
	public static void traverseDfs(TreeItem root, Action<TreeItem> onNode){
		if (onNode == null)
			throw new IllegalArgumentException("Must pass an action.");
		
		Stack<TreeItem> children = new Stack<TreeItem>();
		children.add(root);
		
		while (!children.isEmpty()){
			TreeItem current = children.pop();
			onNode.execute(current);
			List<TreeItem> currentChildren = fetchChildren(current);
			children.addAll(currentChildren);
		}
	}
}

Here is our TreeItemUtilTest.java that uses Mockito:

public void testTraverseDfs(){
		final StringBuffer sb = new StringBuffer();
		
		TreeItem a = createMockedTI("a");
		TreeItem b = createMockedTI("b");
		TreeItem c = createMockedTI("c");
		TreeItem d = createMockedTI("d");
		TreeItem e = createMockedTI("e");
		TreeItem f = createMockedTI("f");
		TreeItem g = createMockedTI("g");
		TreeItem h = createMockedTI("h");
		TreeItem i = createMockedTI("i");
		TreeItem j = createMockedTI("j");
		TreeItem k = createMockedTI("k");
		TreeItem l = createMockedTI("l");
		TreeItem m = createMockedTI("m");
		TreeItem n = createMockedTI("n");
		TreeItem o = createMockedTI("o");
		TreeItem p = createMockedTI("p");
		
		addMockedChildren(a, b, o);
		addMockedChildren(b, c, i);
		addMockedChildren(o, n, p);
		addMockedChildren(c, d);
		addMockedChildren(i, j, m);
		addMockedChildren(d, e);
		addMockedChildren(j, k, l);
		addMockedChildren(e, f, g);
		addMockedChildren(g, h);
		
		TreeItemUtil.traverseDfs(a, new Action<TreeItem>(){
			public void execute(TreeItem current){
				sb.append(current.getText());
			}
		});
		
		//I was assuming it would be leftmost child first, if so, it would be in alphabetical order
		//but it starts with rightmost node first.
		assertEquals("aopnbimjlkcdeghf", sb.toString());
	}
	
	private TreeItem createMockedTI(String text){
		TreeItem ti = mock(TreeItem.class);
		when(ti.getText()).thenReturn(text);
		return ti;
	}
	
	private void addMockedChildren(TreeItem parent, TreeItem... children){
		for (int x = 0; x < children.length; ++x){
			when(parent.getChild(x)).thenReturn(children[x]);
			when(children[x].getParentItem()).thenReturn(parent);
		}
		
		when(parent.getChildCount()).thenReturn(children.length);
	}

Now for the actual algorithm that clones the TreeItem into a TreeItem with checkboxes:

private TreeItem cloneTreeItemsWithCheckboxes(TreeItem root){
		final HashMap<TreeItem, TreeItem> oldNew = new HashMap<TreeItem, TreeItem>();
		
		TreeItemUtil.traverseDfs(root, new Action<TreeItem>(){
			public void execute(TreeItem current){
				TreeItem newTi = new TreeItem(new CheckBox(current.getText()));
				newTi.setUserObject(current.getUserObject());
				oldNew.put(current, newTi);
				
				if (current.getParentItem() != null && oldNew.containsKey(current.getParentItem())){
					TreeItem newParent = oldNew.get(current.getParentItem());
					newParent.addItem(newTi);
				}
			}
		});
		
		return oldNew.get(root);
	}

Are you a Git user? Let me help you make project management with Git simple. Checkout Gitpilot.

Follow me on Twitter: @jprichardson

-JP

Window.addWindowClosingHandler(new ClosingHandler(){
	@Override public void onWindowClosing(ClosingEvent event) {
		event.setMessage("If you leave, you may lose data. Continue?");
	}
});

Simple as pie. If event.setMessage is called, a prompt will be displayed for you.

Are you a Git user? Let me help you make project management with Git simple. Checkout Gitpilot.

Follow me on Twitter: @jprichardson

-JP

Gears offers a method to allow a user to select file(s). You can then use the returned “getFiles” method of the “OpenFilesEvent” object to find out what file(s) the user selected. Each “File” class has a method called “getBlob” that returns a “Blob” object. However, each blob object doesn’t provide any direct way to access the blobs contents. Many people haven’t found a way to read the blob contents.

I wrote a class to access the contents of the blob. The class is called “BlobReader” and is very simple to use. The trick lies in the fact that in Javascript we can access the “getBytes” method of the blob.

Here is an example reading line by line of a text file:

try {
	Desktop dt = Factory.getInstance().createDesktop();
	dt.openFiles(new OpenFilesHandler(){
		public void onOpenFiles(OpenFilesEvent event) {
			File[] files = event.getFiles();
			File file = files[0];
			Blob data = file.getBlob();

			BlobReader br = new BlobReader(data);
			while (!br.endOfBlob())
				Window.alert(br.readLine());
			}
		}, true);
} catch (Exception ex){
	Window.alert(ex.toString());
}

Here is BlobReader.java:

package com.yourpackage.client;
import com.google.gwt.core.client.JsArrayInteger;
import com.google.gwt.gears.client.blob.Blob;

public class BlobReader {

	private final int CHUNK_SIZE = 1024;

	public BlobReader(Blob blob){
		this.blob = blob;
	}

	private Blob blob;
	public Blob getBlob(){ return this.blob; }

	private int blobPointer = 0;
	public int getBlobPointer(){ return this.blobPointer; }

	public boolean endOfBlob(){
		return (blobPointer >= blob.getLength());
	}

	public byte[] readAllBytes(){
		return getBlobBytes(this.blob);
	}

	public String readAllText(){
		int size = this.blob.getLength();
		StringBuilder sb = new StringBuilder(size);

		JsArrayInteger bytes = getBlobBytes(this.blob, 0, size);
		for (int x = 0; x < size; x++)
			sb.append((char)bytes.get(x));

		return sb.toString();
	}

	public String readLine(){
		int size = CHUNK_SIZE;
		boolean foundEndOfLine = false;

		JsArrayInteger bytes;
		StringBuilder sb = new StringBuilder(CHUNK_SIZE);

		while (!foundEndOfLine && size > 0){
			int dif = this.blob.getLength() - this.blobPointer; //remainder of the data
			if (dif < CHUNK_SIZE)
				size = dif;
			bytes = getBlobBytes(this.blob, this.blobPointer, size);

			for (int x = 0; x < size; x++){
				blobPointer++;
				int b = bytes.get(x);
				if (b == 10){ //newline
					foundEndOfLine = true;
					break;
				}
				sb.append((char)b);

				if (this.getBlobPointer() % 1000000 == 0)
					Window.alert("" + this.getBlobPointer());
			}
		}

		if (sb.substring(sb.length() - 1) == "\r")
			sb.deleteCharAt(sb.length() - 1);

		return sb.toString();
	}

       public void reset(){
		this.blobPointer = 0;
	}

	private byte[] getBlobBytes(Blob b){
		JsArrayInteger array = getBlobBytes(b, 0, b.getLength());
		byte[] bytes = new byte[array.length()];
		for (int x = 0; x < bytes.length; x++)
			bytes[x] = (byte) array.get(x); //in google docs we are told these are from 0-255

		return bytes;
	}

	private native JsArrayInteger getBlobBytes(Blob b, int offset, int length) /*-{
		return b.getBytes(offset, length);
	}-*/;
}

Notes:
1) This hasn’t been thoroughly tested/debugged.
2) At the time of this writing, I’m using Gears 0.5 with the GWT-Gears 1.2.1. In the current GWT-Gears svn trunk you can see upcoming support for the GWT methods “getNativeBytes” and “getBytes”

Are you a Git user? Let me help you make project management with Git simple. Checkout Gitpilot.

Enjoy!