Duplicate last tree node

for (MailAccount mailAccount : mailAccounts){
	TreeNode node = toNode(mailAccount, true);
	TreeModel model = tree.getModel();
	TreeNode root = (TreeNode) model.getRoot();
	addNode(root, node);
}

private void addNode(final TreeNode parent, final TreeNode node) {
	Executions.schedule(desktop, new EventListener() {
		@Override
		public void onEvent(Event event) throws Exception {
			parent.add(node);
		}
	}, null);
}

/**
 * Converts the given mail account into a tree node
 * 
 * @param account
 *            The mail account to convert
 * @return The tree node
 * @throws MessagingException
 *             Thrown if something went wrong while checking the mail
 *             account's content (e.g. folders)
 */
public static TreeNode toNode(MailAccount account, boolean recursive) throws MessagingException {
	SmampiTreeNode rootNode = null;
	if (account != null) {
		IncomingMailServer incomingServer = account.getIncomingServer();
		if (incomingServer != null) {
			Set<CachedFolder> cachedFolders = incomingServer.getCachedFolders();
			List<TreeNode> children = new Vector<TreeNode>();

			/*
			 * Create a node for each folder in the mail account
			 * (recursively with all subfolders)
			 */
			if (recursive) {
				if (cachedFolders != null) {
					List<CachedFolder> tmpCachedFolders = new ArrayList<CachedFolder>(cachedFolders);
					for (CachedFolder tmpCachedFolder : tmpCachedFolders) {
						TreeNode folderNode = toNode(tmpCachedFolder, true);
						if (tmpCachedFolder.isInbox(true)) {
							// Put INBOX to the top
							children.add(0, folderNode);
							// Set this folder as the inbox
							tmpCachedFolder.setFolderType(FolderType.INBOX, true);
						} else {
							children.add(folderNode);
						}
					}
				}
			}

			if (children != null) {
				if (children.size() <= 0) {
					children = null;
				}
			}

			// Create the node for "account" and its children and return it
			rootNode = new SmampiTreeNode(account, children);
		}
	}
	return rootNode;
}

/**
 * Converts the given folder into a tree node
 * 
 * @param cachedFolder
 *            The folder to convert
 * @return The tree node
 * @throws MessagingException
 *             Thrown if something went wrong during conversion.
 */
public static TreeNode toNode(CachedFolder cachedFolder, boolean recursive) throws MessagingException {

	Set<CachedFolder> cachedFolders = cachedFolder.getCachedFolders(true);
	List<TreeNode> children = new Vector<TreeNode>();

	// Recursively transform each (sub-)folder into a tree node
	if (recursive) {
		if (cachedFolders != null) {
			List<CachedFolder> tmpCachedFolders = new ArrayList<CachedFolder>(cachedFolders);
			for (CachedFolder tmpCachedFolder : tmpCachedFolders) {
				TreeNode node = null;
				if (tmpCachedFolder.holdsFolders(true)) {
					node = toNode(tmpCachedFolder, true);
					children.add(node);
				} else {
					node = toNode(tmpCachedFolder, true);
					children.add(node);
				}
			}
		}
	}

	if (children != null) {
		if (children.size() <= 0) {
			children = null;
		}
	}

	// Create the node for cachedFolder and return it
	TreeNode rootNode = new SmampiTreeNode(cachedFolder, children);
	return rootNode;
}

/**
 * Own implementation of the ZK TreeNode. Will correctly return true or false if
 * isLeaf() is called.
 */
public class SmampiTreeNode extends DefaultTreeNode {

	private static final long	serialVersionUID	= 5343670451152165601L;
	private boolean				_leaf;

	/**
	 * Constructor method
	 * 
	 * @param data
	 *            The data
	 * @param children
	 *            The children as collection
	 */
	public SmampiTreeNode(Object data, Collection<TreeNode> children) {
		super(data, children);
		if (getChildCount() == 0) {
			_leaf = true;
		}
	}

	/**
	 * Constructor method
	 * 
	 * @param data
	 *            The data
	 * @param children
	 *            The children as array
	 */
	public SmampiTreeNode(Object data, SmampiTreeNode[] children) {
		super(data, children);
		if (getChildCount() == 0) {
			_leaf = true;
		}
	}

	@Override
	public void insert(TreeNode child, int index) {
		if (child != null) {
			_leaf = false;
			super.insert(child, index);
			if (getChildCount() == 0) {
				_leaf = true;
			}
		}
	}

	@Override
	public boolean isLeaf() {
		return _leaf && getChildCount() == 0;
	}

}

tree.setModel(tree.getModel());

for (MailAccount mailAccount : mailAccounts){
	Thread t = new Thread(){
		@Overide
		public void run(){
			TreeNode node = toNode(mailAccount, true);
			TreeModel model = tree.getModel();
			TreeNode root = (TreeNode) model.getRoot();
			addNode(root, node);
		}
	}
	t.start();
}