bundles/org.eclipse.jface.databinding/src/org/eclipse/jface/internal/databinding/viewers/TreeViewerUpdatableTree.java - platform/eclipse.platform.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jface.internal.databinding.viewers;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 import org.eclipse.jface.databinding.ChangeEvent;
 import org.eclipse.jface.databinding.IUpdatableTree;
 import org.eclipse.jface.databinding.Updatable;
 import org.eclipse.jface.internal.databinding.swt.AsyncRunnable;
 import org.eclipse.jface.internal.databinding.swt.SyncRunnable;
 import org.eclipse.jface.viewers.ITreeContentProvider;
 import org.eclipse.jface.viewers.TreeViewer;
 import org.eclipse.jface.viewers.Viewer;

 /**
  * @since 3.2
  *
  */
 //TODO Thread safe
 public class TreeViewerUpdatableTree extends Updatable implements IUpdatableTree {

 	protected TreeViewer viewer;

 	// TODO use identityWrapper
 	private Map nodes = new HashMap();

 	private Object rootKey=this;

 	private Object viewerInput=null;

 	private boolean updatingViewer=false;

 	private boolean updatingVirtual=false;

 	private List viewerRefreshList = new ArrayList();

 	Class[] classTypes;

 	private class TreeNode {
 		Object parent;
 		List   children;
 		boolean requestedChildren=false;
 		private TreeNode(Object parent, List children) {
 			this.parent=parent;
 			this.children=children;
 		}
 		private TreeNode(Object parent) {
 			this(parent, null);
 		}
 		/**
 		 * @return a List, the children of this node
 		 */
 		public List getChildren() {
 			return children;
 		}
 		/**
 		 * @return an Object, the parent of this Node
 		 */
 		public Object getParent() {
 			return parent;
 		}
 		/**
 		 * @param children
 		 */
 		public void setChildren(List children) {
 			this.children = children;
 			requestedChildren=false;
 		}
 		/**
 		 * @return true if VIRTUAL request has been made already
 		 */
 		public boolean isRequestedChildren() {
 			return requestedChildren;
 		}
 		/**
 		 * @param requestedChildren
 		 */
 		public void setRequestedChildren(boolean requestedChildren) {
 			this.requestedChildren = requestedChildren;
 		}
 	}


 	/**
 	 * @param viewer
 	 */
 	public TreeViewerUpdatableTree(final TreeViewer viewer) {
 		this (viewer, new Class[] { Object.class } );
 	}
 	/**
 	 * @param viewer
 	 * @param classTypes
 	 */
 	public TreeViewerUpdatableTree(final TreeViewer viewer, Class[] classTypes) {
 		this.viewer = viewer;
 		this.classTypes=classTypes;

 		viewer.setContentProvider(new ITreeContentProvider() {
 			public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 				viewerInput=newInput;
 			}
 			public void dispose() {}
 			public Object[] getElements(Object inputElement) {
 				return TreeViewerUpdatableTree.this.getElements(inputElement);
 			}
 			public boolean hasChildren(final Object element) {
 				return TreeViewerUpdatableTree.this.hasChildren(element);
 			}
 			public Object getParent(Object element) {
 				TreeNode node = getTreeNode(element);
 				if (node!=null)
 					return node.getParent();
 				return null;
 			}
 			public Object[] getChildren(Object parentElement) {
 				return TreeViewerUpdatableTree.this.getElements(parentElement);
 			}
 		});

 		this.viewer.setInput(this);
 	}

 	protected TreeNode getTreeNode(Object element) {
 		if (element==null || element==rootKey || element==viewerInput) {
 			TreeNode result = (TreeNode) nodes.get(rootKey);
 			if (result==null) {
 				result = new TreeNode(null);
 				nodes.put(rootKey, result);
 			}
 			return result;
 		}
 		return (TreeNode)nodes.get(element);
 	}

 	private int primAddChildElement(List list, Object element, int index) {
 		int position;
 		if (index < 0 || index > list.size()) {
 			position = list.size();
 			list.add(element);
 		} else {
 			list.add(index, element);
 			position = index;
 		}
 		return position;
 	}

 	protected void updateViewer(Runnable runable) {
 		if (updatingViewer) {
 			viewerRefreshList.add(runable);
 			return ;
 		}

 		updatingViewer=true;
 		try {
 			runable.run();
 		}
 		finally {
 			updatingViewer=false;
 		}
 		//	Virtual events may need to update the viewer as well
 		while (!viewerRefreshList.isEmpty()) {
 		   Runnable work[] = (Runnable[])viewerRefreshList.toArray(new Runnable[viewerRefreshList.size()]);
 		   viewerRefreshList.clear();
 		   for (int i = 0; i < work.length; i++)
 			updateViewer(work[i]);
 		}
 	}

 	public int addElement(final Object parentElement, final int index, final Object value) {
 		SyncRunnable runnable = new SyncRunnable() {
 			public Object run() {
 				return new Integer(addElement(parentElement, index, value, true));
 			}
 		};
 		return ((Integer)runnable.run()).intValue();
 	}


 	protected int addElement(final Object parentElement, int index, final Object value, final boolean fire) {
 		TreeNode parentNode = getTreeNode(parentElement);
 		if (parentNode == null) return -1;


 		if (!hasChildren(parentElement) && parentNode.getChildren()==null)
 			parentNode.setChildren(new ArrayList());
 		List list = parentNode.getChildren();
 		int addedIndex = -1;
 		if (!list.contains(value)) {
 			addedIndex = primAddChildElement(list, value, index);
 			TreeNode valueNode = new TreeNode(parentElement);
 			nodes.put(value, valueNode);
 			final int fireIndex=addedIndex;
 			updateViewer(new Runnable() {
 				public void run() {
 					viewer.add(parentElement == null ? viewerInput : parentElement,
 							value);
 					if (fire)
 						fireChangeEvent(ChangeEvent.ADD, null, value, parentElement, fireIndex);
 				}
 			});
 		}
 		return addedIndex;
 	}


 	public void removeElement(final Object parentElement, final int index) {
 		SyncRunnable runnable = new SyncRunnable() {
 			public Object run() {
 				removeElement(parentElement, index, true);
 				return null;
 			}
 		};
 		runnable.run();
 	}


 	protected void removeElement(final Object parentElement, final int index, final boolean fire) {
 		if (hasChildren(parentElement)) {
 			TreeNode parentNode = getTreeNode(parentElement);
 			List children = parentNode.getChildren();
 			if (children!=null) {
 				final Object element = children.remove(index);
 				updateViewer(new Runnable() {
 					public void run() {
 							viewer.remove(element);
 							if (fire)
 								fireChangeEvent(ChangeEvent.REMOVE, element, null, parentElement, index);
 					}
 				});
 			}
 			if (children.size()==0)
 				parentNode.setChildren(null);
 			}
 	}


 	public void setElement(final Object parentElement, final int index, final Object value) {
 		AsyncRunnable runnable = new AsyncRunnable() {
 			public void run() {
 				if (hasChildren(parentElement)) {
 					TreeNode parentNode = getTreeNode(parentElement);
 					List children = parentNode.getChildren();
 					Object oldValue = children.get(index);
 					if (oldValue.equals(value)) {
 						updateViewer(new Runnable() {
 							public void run() {
 								viewer.update(value, null);
 							}
 						});
 					} else {
 						removeElement(parentElement, index, false);
 						addElement(parentElement, index, value, false);
 					}
 					fireChangeEvent(ChangeEvent.CHANGE, oldValue, value,
 							parentElement, index);
 				}

 			}
 		};
 		runnable.runOn(viewer.getTree().getDisplay());
 	}

 	public void setElements(final Object parentElement, final Object[] values) {
 		SyncRunnable runnable = new SyncRunnable() {
 			public Object run() {
 				hasChildren(parentElement); // prime Children if needed
 				TreeNode parentNode = getTreeNode(parentElement);
 				if (parentNode == null)
 					return null;

 				List children = parentNode.getChildren();
 				if (children != null) {
 					while (children.size() > 0)
 						removeElement(parentElement, 0, true);
 				}
 				parentNode.setRequestedChildren(true);
 				if (values != null)
 					for (int i = 0; i < values.length; i++) {
 						addElement(parentElement, i, values[i], true);
 					}
 				return null;
 			}
 		};
 		runnable.runOn(viewer.getTree().getDisplay());
 	}


 	public Object getElement(Object parentElement, int index) {
 		Object element = null;
 		if (hasChildren(parentElement)) {
 			TreeNode parentNode = getTreeNode(parentElement);
 			if (parentNode!=null) {
 				List children = parentNode.getChildren();
 				if (children!=null)
 					if (index>=0&&index<children.size())
 						element = children.get(index);
 			}
 		}
 		return element;
 	}


 	public Object[] getElements(Object parentElement) {
 		if (hasChildren(parentElement)) {
 			TreeNode parentNode = getTreeNode(parentElement);

 			List children = parentNode==null? null : parentNode.getChildren();
 			return children==null? Collections.EMPTY_LIST.toArray():children.toArray();
 		}
 		return Collections.EMPTY_LIST.toArray();
 	}


 	/**
 	 * This method will drive <code>ChangeElement.VIRTUAL</code> if no
 	 * childrent are set.
 	 *
 	 * @param element
 	 * @return true if element has children, false if not
 	 */
 	public boolean hasChildren(final Object element) {
 		TreeNode node = getTreeNode(element);
 		if (node==null) return false;
 		boolean have = node.getChildren()!=null && node.getChildren().size()>0;
 		if (!have && !updatingVirtual && !node.isRequestedChildren()) {
 			    updatingVirtual=true;
 				try {
 					fireChangeEvent(ChangeEvent.VIRTUAL, null, null, element, -1);
 					// Once asked, the assumption is that the model will listen, and update
 					// if a new child is added
 					node.setRequestedChildren(true);
 					// VIRTUAL processing may or may not be on the same thread
 					// In any case, the binder will come back with the right answer
 					// eventually
 					have = node.getChildren()!=null && node.getChildren().size()>0;
 			    }
 			    finally {
 			    	updatingVirtual=false;
 			    }
 		}
 		return have;
 	}

 	/**
 	 * @param element
 	 * @return element's parent
 	 */
 	public Object getParent(Object element) {
 		TreeNode elementNode = (TreeNode)nodes.get(element);
 		return elementNode.getParent();
 	}

 	public Class[] getTypes() {
 		return classTypes;
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2005 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jface.internal.databinding.viewers;

	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;

	import org.eclipse.jface.databinding.ChangeEvent;
	import org.eclipse.jface.databinding.IUpdatableTree;
	import org.eclipse.jface.databinding.Updatable;
	import org.eclipse.jface.internal.databinding.swt.AsyncRunnable;
	import org.eclipse.jface.internal.databinding.swt.SyncRunnable;
	import org.eclipse.jface.viewers.ITreeContentProvider;
	import org.eclipse.jface.viewers.TreeViewer;
	import org.eclipse.jface.viewers.Viewer;

	/**
	* @since 3.2
	*
	*/
	//TODO Thread safe
	public class TreeViewerUpdatableTree extends Updatable implements IUpdatableTree {

	protected TreeViewer viewer;

	// TODO use identityWrapper
	private Map nodes = new HashMap();

	private Object rootKey=this;

	private Object viewerInput=null;

	private boolean updatingViewer=false;

	private boolean updatingVirtual=false;

	private List viewerRefreshList = new ArrayList();

	Class[] classTypes;

	private class TreeNode {
	Object parent;
	List children;
	boolean requestedChildren=false;
	private TreeNode(Object parent, List children) {
	this.parent=parent;
	this.children=children;
	}
	private TreeNode(Object parent) {
	this(parent, null);
	}
	/**
	* @return a List, the children of this node
	*/
	public List getChildren() {
	return children;
	}
	/**
	* @return an Object, the parent of this Node
	*/
	public Object getParent() {
	return parent;
	}
	/**
	* @param children
	*/
	public void setChildren(List children) {
	this.children = children;
	requestedChildren=false;
	}
	/**
	* @return true if VIRTUAL request has been made already
	*/
	public boolean isRequestedChildren() {
	return requestedChildren;
	}
	/**
	* @param requestedChildren
	*/
	public void setRequestedChildren(boolean requestedChildren) {
	this.requestedChildren = requestedChildren;
	}
	}


	/**
	* @param viewer
	*/
	public TreeViewerUpdatableTree(final TreeViewer viewer) {
	this (viewer, new Class[] { Object.class } );
	}
	/**
	* @param viewer
	* @param classTypes
	*/
	public TreeViewerUpdatableTree(final TreeViewer viewer, Class[] classTypes) {
	this.viewer = viewer;
	this.classTypes=classTypes;

	viewer.setContentProvider(new ITreeContentProvider() {
	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
	viewerInput=newInput;
	}
	public void dispose() {}
	public Object[] getElements(Object inputElement) {
	return TreeViewerUpdatableTree.this.getElements(inputElement);
	}
	public boolean hasChildren(final Object element) {
	return TreeViewerUpdatableTree.this.hasChildren(element);
	}
	public Object getParent(Object element) {
	TreeNode node = getTreeNode(element);
	if (node!=null)
	return node.getParent();
	return null;
	}
	public Object[] getChildren(Object parentElement) {
	return TreeViewerUpdatableTree.this.getElements(parentElement);
	}
	});

	this.viewer.setInput(this);
	}

	protected TreeNode getTreeNode(Object element) {
	if (element==null \|\| element==rootKey \|\| element==viewerInput) {
	TreeNode result = (TreeNode) nodes.get(rootKey);
	if (result==null) {
	result = new TreeNode(null);
	nodes.put(rootKey, result);
	}
	return result;
	}
	return (TreeNode)nodes.get(element);
	}

	private int primAddChildElement(List list, Object element, int index) {
	int position;
	if (index < 0 \|\| index > list.size()) {
	position = list.size();
	list.add(element);
	} else {
	list.add(index, element);
	position = index;
	}
	return position;
	}

	protected void updateViewer(Runnable runable) {
	if (updatingViewer) {
	viewerRefreshList.add(runable);
	return ;
	}

	updatingViewer=true;
	try {
	runable.run();
	}
	finally {
	updatingViewer=false;
	}
	// Virtual events may need to update the viewer as well
	while (!viewerRefreshList.isEmpty()) {
	Runnable work[] = (Runnable[])viewerRefreshList.toArray(new Runnable[viewerRefreshList.size()]);
	viewerRefreshList.clear();
	for (int i = 0; i < work.length; i++)
	updateViewer(work[i]);
	}
	}

	public int addElement(final Object parentElement, final int index, final Object value) {
	SyncRunnable runnable = new SyncRunnable() {
	public Object run() {
	return new Integer(addElement(parentElement, index, value, true));
	}
	};
	return ((Integer)runnable.run()).intValue();
	}


	protected int addElement(final Object parentElement, int index, final Object value, final boolean fire) {
	TreeNode parentNode = getTreeNode(parentElement);
	if (parentNode == null) return -1;


	if (!hasChildren(parentElement) && parentNode.getChildren()==null)
	parentNode.setChildren(new ArrayList());
	List list = parentNode.getChildren();
	int addedIndex = -1;
	if (!list.contains(value)) {
	addedIndex = primAddChildElement(list, value, index);
	TreeNode valueNode = new TreeNode(parentElement);
	nodes.put(value, valueNode);
	final int fireIndex=addedIndex;
	updateViewer(new Runnable() {
	public void run() {
	viewer.add(parentElement == null ? viewerInput : parentElement,
	value);
	if (fire)
	fireChangeEvent(ChangeEvent.ADD, null, value, parentElement, fireIndex);
	}
	});
	}
	return addedIndex;
	}


	public void removeElement(final Object parentElement, final int index) {
	SyncRunnable runnable = new SyncRunnable() {
	public Object run() {
	removeElement(parentElement, index, true);
	return null;
	}
	};
	runnable.run();
	}


	protected void removeElement(final Object parentElement, final int index, final boolean fire) {
	if (hasChildren(parentElement)) {
	TreeNode parentNode = getTreeNode(parentElement);
	List children = parentNode.getChildren();
	if (children!=null) {
	final Object element = children.remove(index);
	updateViewer(new Runnable() {
	public void run() {
	viewer.remove(element);
	if (fire)
	fireChangeEvent(ChangeEvent.REMOVE, element, null, parentElement, index);
	}
	});
	}
	if (children.size()==0)
	parentNode.setChildren(null);
	}
	}


	public void setElement(final Object parentElement, final int index, final Object value) {
	AsyncRunnable runnable = new AsyncRunnable() {
	public void run() {
	if (hasChildren(parentElement)) {
	TreeNode parentNode = getTreeNode(parentElement);
	List children = parentNode.getChildren();
	Object oldValue = children.get(index);
	if (oldValue.equals(value)) {
	updateViewer(new Runnable() {
	public void run() {
	viewer.update(value, null);
	}
	});
	} else {
	removeElement(parentElement, index, false);
	addElement(parentElement, index, value, false);
	}
	fireChangeEvent(ChangeEvent.CHANGE, oldValue, value,
	parentElement, index);
	}

	}
	};
	runnable.runOn(viewer.getTree().getDisplay());
	}

	public void setElements(final Object parentElement, final Object[] values) {
	SyncRunnable runnable = new SyncRunnable() {
	public Object run() {
	hasChildren(parentElement); // prime Children if needed
	TreeNode parentNode = getTreeNode(parentElement);
	if (parentNode == null)
	return null;

	List children = parentNode.getChildren();
	if (children != null) {
	while (children.size() > 0)
	removeElement(parentElement, 0, true);
	}
	parentNode.setRequestedChildren(true);
	if (values != null)
	for (int i = 0; i < values.length; i++) {
	addElement(parentElement, i, values[i], true);
	}
	return null;
	}
	};
	runnable.runOn(viewer.getTree().getDisplay());
	}


	public Object getElement(Object parentElement, int index) {
	Object element = null;
	if (hasChildren(parentElement)) {
	TreeNode parentNode = getTreeNode(parentElement);
	if (parentNode!=null) {
	List children = parentNode.getChildren();
	if (children!=null)
	if (index>=0&&index<children.size())
	element = children.get(index);
	}
	}
	return element;
	}


	public Object[] getElements(Object parentElement) {
	if (hasChildren(parentElement)) {
	TreeNode parentNode = getTreeNode(parentElement);

	List children = parentNode==null? null : parentNode.getChildren();
	return children==null? Collections.EMPTY_LIST.toArray():children.toArray();
	}
	return Collections.EMPTY_LIST.toArray();
	}


	/**
	* This method will drive <code>ChangeElement.VIRTUAL</code> if no
	* childrent are set.
	*
	* @param element
	* @return true if element has children, false if not
	*/
	public boolean hasChildren(final Object element) {
	TreeNode node = getTreeNode(element);
	if (node==null) return false;
	boolean have = node.getChildren()!=null && node.getChildren().size()>0;
	if (!have && !updatingVirtual && !node.isRequestedChildren()) {
	updatingVirtual=true;
	try {
	fireChangeEvent(ChangeEvent.VIRTUAL, null, null, element, -1);
	// Once asked, the assumption is that the model will listen, and update
	// if a new child is added
	node.setRequestedChildren(true);
	// VIRTUAL processing may or may not be on the same thread
	// In any case, the binder will come back with the right answer
	// eventually
	have = node.getChildren()!=null && node.getChildren().size()>0;
	}
	finally {
	updatingVirtual=false;
	}
	}
	return have;
	}

	/**
	* @param element
	* @return element's parent
	*/
	public Object getParent(Object element) {
	TreeNode elementNode = (TreeNode)nodes.get(element);
	return elementNode.getParent();
	}

	public Class[] getTypes() {
	return classTypes;
	}

	}