bundles/org.eclipse.jface.databinding/src/org/eclipse/jface/internal/databinding/beans/JavaBeanTree.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.beans;

 import java.beans.PropertyChangeListener;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Set;

 import org.eclipse.jface.databinding.BindingException;
 import org.eclipse.jface.databinding.ChangeEvent;
 import org.eclipse.jface.databinding.IChangeListener;
 import org.eclipse.jface.databinding.ITree;
 import org.eclipse.jface.databinding.TreeModelDescription;

 /**
  * This class is a JavaBean implementation for a ITree.  It is a ITree facade that is built
  * from a <code>TreeModelDescription</code>
  */
 public class JavaBeanTree implements ITree {

 	/**
 	 * Keep track of element parents, and children
 	 * @since 3.2
 	 */
 	private class TreeNode {
 		private Object parent;
 		private List children;

 		/**
 		 * @param parent
 		 */
 		public TreeNode(Object parent) {
 			this.parent=parent;
 		}

 		/**
 		 * @return children
 		 */
 		public List getChildren() {
 			return children==null? Collections.EMPTY_LIST: children;
 		}

 		/**
 		 * @param children
 		 */
 		public void setChildren(List children) {
 			this.children = children;
 		}

 		/**
 		 * @return parent
 		 */
 		public Object getParent() {
 			return parent;
 		}
 	}

 	private final static int READ = 0;

 	private final static int WRITE = 1;

 	private TreeModelDescription modelDescription;

 	private Object[]  rootElements;

 	private HashMap descriptors = new HashMap();

 	private ITree.ChangeSupport changeSupport = null;

 	private HashMap nodes = new HashMap();

 	private boolean updating = false;


 	private PropertyChangeListener elementListener = new PropertyChangeListener() {
 		public void propertyChange(java.beans.PropertyChangeEvent event) {
 			if (!updating && changeSupport!=null) {
 				String[] properties = modelDescription.getChildrenProperties(event.getSource().getClass());
 				// Determine if the change is on a children Property, in which case
 				// that level of the tree has changed.
 				if (properties!=null && event.getPropertyName()!=null &&
 						Arrays.asList(properties).contains(event.getPropertyName())) {
 					// Assume children have changed
 					changeSupport.fireTreeChange(ChangeEvent.REPLACE, null, getChildren(event.getSource()), event.getSource(), -1);
 				}
 				else {
 					// Assume a property has changed that may change the way this element
 					// is rendered in a viewer, use our tracking to figure out the index.
 					TreeNode node = (TreeNode)nodes.get(event.getSource());
 					if (node!=null) {
 						int index = -1;
 						Object[] children = getChildren(node.getParent());
 						if (children!=null) {
 							index = Arrays.asList(children).indexOf(event.getSource());
 						}
 						if (index<0) index = ChangeEvent.POSITION_UNKNOWN;
 					    changeSupport.fireTreeChange(ChangeEvent.CHANGE, null, event.getSource(), node.getParent(), index);
 					}
 				}
 			}
 		}
 	};

 	HashMap listenerSupport = new HashMap();

 	/**
 	 * @param modelDescripton
 	 */
 	public JavaBeanTree(TreeModelDescription modelDescripton) {
 		this.modelDescription = modelDescripton;
 		if (modelDescripton.getRoot()==null)
 			rootElements = Collections.EMPTY_LIST.toArray();
 		else
 			rootElements = modelDescripton.getRoot().getClass().isArray()?
 				          (Object[]) modelDescripton.getRoot():
 				           new Object[] { modelDescripton.getRoot() };
 		TreeNode root = new TreeNode(null);
 		nodes.put(this, root);
 		hookup(null, rootElements);
 	}


 	// pick up the leaf most registered class that is assignable
 	// from o.class.
 	private Class getRelevantClass(Object o) {
 		if (o==null)
 			return null;
 		Class leafClass = null;
 		Class current = o.getClass();
 		Class[] list = modelDescription.getTypes();
 		for (int i = 0; i < list.length; i++)
 			if (list[i].isAssignableFrom(current)) {
 				// found registered class
 				if (leafClass==null)
 					leafClass=list[i];
 				else
 					if (leafClass.isAssignableFrom(list[i]))
 							leafClass=list[i];
 			}
 		return leafClass;
 	}

 	private Method[] getInvocationMethods(Class clazz, int methodType) {
 		if (clazz==null)
 			return null;
 		String[] childrenProperties = modelDescription
 				.getChildrenProperties(clazz);
 		if (childrenProperties == null || childrenProperties.length == 0)
 			return null;

 		PropertyHelper[] properties = (PropertyHelper[]) descriptors.get(clazz);
 		if (properties == null) {
 			List newpProperties = new ArrayList();

 			// Walk by properties to preserve the tree order
 			for (int i = 0; i < childrenProperties.length; i++) {
 				PropertyHelper property = new PropertyHelper(
 						childrenProperties[i], clazz);
 				if (property.getGetter() != null ||  property.getSetter() != null) {
 					newpProperties.add(property);
 				}
 			}

 			properties = (PropertyHelper[]) newpProperties
 					.toArray(new PropertyHelper[newpProperties.size()]);
 			descriptors.put(clazz, properties);

 		}
 		List methods = new ArrayList();
 		for (int i = 0; i < properties.length; i++) {
 			if (methodType==READ)
 				methods.add(properties[i].getGetter());
 			else
 				methods.add(properties[i].getSetter());
 		}
 		return (Method[])methods.toArray(new Method[methods.size()]);
 	}

 	private Method[] getReadMethods(Object element) {
 		Class clazz = getRelevantClass(element);
 		if (clazz==null) return null;

 		Method[] methods = getInvocationMethods(clazz, READ);
 		return methods;
 	}


 	private Method[] getWriteMethods (Object element) {
 		Class clazz = getRelevantClass(element);
 		if (clazz==null) return null;
 		Method[] methods = getInvocationMethods(clazz, WRITE);
 		return methods;
 	}

 	private void hookup (Object parent, Object[] children) {
 		Object key = parent==null?JavaBeanTree.this:parent;

 		ListenerSupport support = (ListenerSupport) listenerSupport.get(key);
 		if (support==null) {
 			support = new ListenerSupport(elementListener);
 			listenerSupport.put(key, support);
 		}
 		support.setHookTargets(children);
 		// Track a child's index
 		trackChildren(parent, children);
 	}

 	public Object[] getChildren(Object parentElement) {
 		if (parentElement==null)
 			return rootElements;


 		Method[] getters = getReadMethods(parentElement);
 		if (getters==null)
 			return Collections.EMPTY_LIST.toArray();

 		List children = new ArrayList();

 		try {
 			for (int i = 0; i < getters.length; i++) {
 				Object list = getters[i].invoke(parentElement, new Object[0]);
 				if (list!=null) {
 					if (getters[i].getReturnType().isArray())
 						children.addAll(Arrays.asList((Object[])list));
 					else
 					    children.addAll((Collection) getters[i].invoke(parentElement, new Object[0]));
 				}
 			}
 		} catch (IllegalArgumentException e) {
 			throw new BindingException(e.getLocalizedMessage());
 		} catch (IllegalAccessException e) {
 			throw new BindingException(e.getLocalizedMessage());
 		} catch (InvocationTargetException e) {
 			throw new BindingException(e.getLocalizedMessage());
 		}
 		Object[] result = children.toArray();
 		hookup(parentElement, result);
 		trackChildren(parentElement, result);
 		return result;
 	}

 	private void trackChildren(Object parentElement, Object[] children) {
 		Object key = parentElement==null?JavaBeanTree.this : parentElement;
 		TreeNode node = (TreeNode) nodes.get(key);
 		Set removed = new HashSet(node.getChildren());
 		List newList = children==null? new ArrayList(): Arrays.asList(children);
 		if (children!=null)
 			for (int i=0; i<children.length; i++) {
 				if (!removed.remove(children[i])) {
 					// new child
 					TreeNode child = new TreeNode(parentElement);
 					nodes.put(children[i], child);
 				}
 			}
 		for (Iterator itr=removed.iterator(); itr.hasNext();)
 			nodes.remove(itr.next());
 		node.setChildren(newList);
 	}

 	public void setChildren(Object parentElement, Object[] children) {
 		if (parentElement==null)
 			throw new BindingException ("Changing root element/s is not supported"); //$NON-NLS-1$

 		Method[] setters = getWriteMethods(parentElement);
 		// TODO we can try to figure out (by type) which methods to invoke on which object
 		if (setters==null || setters.length!=1)
 			throw new BindingException("Can not determine children set method for: "+parentElement.getClass().getName()); //$NON-NLS-1$

 		Method setter = setters[0];
 		Class[] parameters = setter.getParameterTypes();
 		Object arg;
 		if (parameters[0].isArray())
 			arg = children;
 		else
 			arg = Arrays.asList(children);
 		try {
 			setter.invoke(parentElement, new Object[] { arg } );
 		} catch (IllegalArgumentException e) {
 			throw new BindingException(e.getLocalizedMessage());
 		} catch (IllegalAccessException e) {
 			throw new BindingException(e.getLocalizedMessage());
 		} catch (InvocationTargetException e) {
 			throw new BindingException(e.getLocalizedMessage());
 		}
 		hookup(parentElement, children);
 		if (changeSupport!=null)
 		   changeSupport.fireTreeChange(ChangeEvent.REPLACE, null, children, parentElement, -1);
 	}

 	public boolean hasChildren(Object element) {
 		Object[] children = getChildren(element);
 		return (children!=null && children.length>0);
 	}

 	public Class[] getTypes() {
 		return modelDescription.getTypes();
 	}

 	public void addTreeChangeListener(IChangeListener listener) {
 		if (listener==null)
 			return;
 		if (changeSupport==null)
 			changeSupport = new ITree.ChangeSupport(this);
 		changeSupport.addTreeChangeListener(listener);
 	}

 	public void removeTreeChangeListener(IChangeListener listener) {
 		if (listener==null || changeSupport==null)
 			return;

 		changeSupport.removeTreeChangeListener(listener);
 	}

 	public void dispose() {
 		if (listenerSupport!=null) {
 		  for (Iterator itr=listenerSupport.values().iterator(); itr.hasNext();)
 		   ((ListenerSupport)itr.next()).dispose();
 		  listenerSupport=null;
 		  descriptors=null;
 		  changeSupport=null;
 		  modelDescription=null;
 		}
 	}


 }
	/*******************************************************************************
	* 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.beans;

	import java.beans.PropertyChangeListener;
	import java.lang.reflect.InvocationTargetException;
	import java.lang.reflect.Method;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collection;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Set;

	import org.eclipse.jface.databinding.BindingException;
	import org.eclipse.jface.databinding.ChangeEvent;
	import org.eclipse.jface.databinding.IChangeListener;
	import org.eclipse.jface.databinding.ITree;
	import org.eclipse.jface.databinding.TreeModelDescription;

	/**
	* This class is a JavaBean implementation for a ITree. It is a ITree facade that is built
	* from a <code>TreeModelDescription</code>
	*/
	public class JavaBeanTree implements ITree {

	/**
	* Keep track of element parents, and children
	* @since 3.2
	*/
	private class TreeNode {
	private Object parent;
	private List children;

	/**
	* @param parent
	*/
	public TreeNode(Object parent) {
	this.parent=parent;
	}

	/**
	* @return children
	*/
	public List getChildren() {
	return children==null? Collections.EMPTY_LIST: children;
	}

	/**
	* @param children
	*/
	public void setChildren(List children) {
	this.children = children;
	}

	/**
	* @return parent
	*/
	public Object getParent() {
	return parent;
	}
	}

	private final static int READ = 0;

	private final static int WRITE = 1;

	private TreeModelDescription modelDescription;

	private Object[] rootElements;

	private HashMap descriptors = new HashMap();

	private ITree.ChangeSupport changeSupport = null;

	private HashMap nodes = new HashMap();

	private boolean updating = false;


	private PropertyChangeListener elementListener = new PropertyChangeListener() {
	public void propertyChange(java.beans.PropertyChangeEvent event) {
	if (!updating && changeSupport!=null) {
	String[] properties = modelDescription.getChildrenProperties(event.getSource().getClass());
	// Determine if the change is on a children Property, in which case
	// that level of the tree has changed.
	if (properties!=null && event.getPropertyName()!=null &&
	Arrays.asList(properties).contains(event.getPropertyName())) {
	// Assume children have changed
	changeSupport.fireTreeChange(ChangeEvent.REPLACE, null, getChildren(event.getSource()), event.getSource(), -1);
	}
	else {
	// Assume a property has changed that may change the way this element
	// is rendered in a viewer, use our tracking to figure out the index.
	TreeNode node = (TreeNode)nodes.get(event.getSource());
	if (node!=null) {
	int index = -1;
	Object[] children = getChildren(node.getParent());
	if (children!=null) {
	index = Arrays.asList(children).indexOf(event.getSource());
	}
	if (index<0) index = ChangeEvent.POSITION_UNKNOWN;
	changeSupport.fireTreeChange(ChangeEvent.CHANGE, null, event.getSource(), node.getParent(), index);
	}
	}
	}
	}
	};

	HashMap listenerSupport = new HashMap();

	/**
	* @param modelDescripton
	*/
	public JavaBeanTree(TreeModelDescription modelDescripton) {
	this.modelDescription = modelDescripton;
	if (modelDescripton.getRoot()==null)
	rootElements = Collections.EMPTY_LIST.toArray();
	else
	rootElements = modelDescripton.getRoot().getClass().isArray()?
	(Object[]) modelDescripton.getRoot():
	new Object[] { modelDescripton.getRoot() };
	TreeNode root = new TreeNode(null);
	nodes.put(this, root);
	hookup(null, rootElements);
	}


	// pick up the leaf most registered class that is assignable
	// from o.class.
	private Class getRelevantClass(Object o) {
	if (o==null)
	return null;
	Class leafClass = null;
	Class current = o.getClass();
	Class[] list = modelDescription.getTypes();
	for (int i = 0; i < list.length; i++)
	if (list[i].isAssignableFrom(current)) {
	// found registered class
	if (leafClass==null)
	leafClass=list[i];
	else
	if (leafClass.isAssignableFrom(list[i]))
	leafClass=list[i];
	}
	return leafClass;
	}

	private Method[] getInvocationMethods(Class clazz, int methodType) {
	if (clazz==null)
	return null;
	String[] childrenProperties = modelDescription
	.getChildrenProperties(clazz);
	if (childrenProperties == null \|\| childrenProperties.length == 0)
	return null;

	PropertyHelper[] properties = (PropertyHelper[]) descriptors.get(clazz);
	if (properties == null) {
	List newpProperties = new ArrayList();

	// Walk by properties to preserve the tree order
	for (int i = 0; i < childrenProperties.length; i++) {
	PropertyHelper property = new PropertyHelper(
	childrenProperties[i], clazz);
	if (property.getGetter() != null \|\| property.getSetter() != null) {
	newpProperties.add(property);
	}
	}

	properties = (PropertyHelper[]) newpProperties
	.toArray(new PropertyHelper[newpProperties.size()]);
	descriptors.put(clazz, properties);

	}
	List methods = new ArrayList();
	for (int i = 0; i < properties.length; i++) {
	if (methodType==READ)
	methods.add(properties[i].getGetter());
	else
	methods.add(properties[i].getSetter());
	}
	return (Method[])methods.toArray(new Method[methods.size()]);
	}

	private Method[] getReadMethods(Object element) {
	Class clazz = getRelevantClass(element);
	if (clazz==null) return null;

	Method[] methods = getInvocationMethods(clazz, READ);
	return methods;
	}


	private Method[] getWriteMethods (Object element) {
	Class clazz = getRelevantClass(element);
	if (clazz==null) return null;
	Method[] methods = getInvocationMethods(clazz, WRITE);
	return methods;
	}

	private void hookup (Object parent, Object[] children) {
	Object key = parent==null?JavaBeanTree.this:parent;

	ListenerSupport support = (ListenerSupport) listenerSupport.get(key);
	if (support==null) {
	support = new ListenerSupport(elementListener);
	listenerSupport.put(key, support);
	}
	support.setHookTargets(children);
	// Track a child's index
	trackChildren(parent, children);
	}

	public Object[] getChildren(Object parentElement) {
	if (parentElement==null)
	return rootElements;


	Method[] getters = getReadMethods(parentElement);
	if (getters==null)
	return Collections.EMPTY_LIST.toArray();

	List children = new ArrayList();

	try {
	for (int i = 0; i < getters.length; i++) {
	Object list = getters[i].invoke(parentElement, new Object[0]);
	if (list!=null) {
	if (getters[i].getReturnType().isArray())
	children.addAll(Arrays.asList((Object[])list));
	else
	children.addAll((Collection) getters[i].invoke(parentElement, new Object[0]));
	}
	}
	} catch (IllegalArgumentException e) {
	throw new BindingException(e.getLocalizedMessage());
	} catch (IllegalAccessException e) {
	throw new BindingException(e.getLocalizedMessage());
	} catch (InvocationTargetException e) {
	throw new BindingException(e.getLocalizedMessage());
	}
	Object[] result = children.toArray();
	hookup(parentElement, result);
	trackChildren(parentElement, result);
	return result;
	}

	private void trackChildren(Object parentElement, Object[] children) {
	Object key = parentElement==null?JavaBeanTree.this : parentElement;
	TreeNode node = (TreeNode) nodes.get(key);
	Set removed = new HashSet(node.getChildren());
	List newList = children==null? new ArrayList(): Arrays.asList(children);
	if (children!=null)
	for (int i=0; i<children.length; i++) {
	if (!removed.remove(children[i])) {
	// new child
	TreeNode child = new TreeNode(parentElement);
	nodes.put(children[i], child);
	}
	}
	for (Iterator itr=removed.iterator(); itr.hasNext();)
	nodes.remove(itr.next());
	node.setChildren(newList);
	}

	public void setChildren(Object parentElement, Object[] children) {
	if (parentElement==null)
	throw new BindingException ("Changing root element/s is not supported"); //$NON-NLS-1$

	Method[] setters = getWriteMethods(parentElement);
	// TODO we can try to figure out (by type) which methods to invoke on which object
	if (setters==null \|\| setters.length!=1)
	throw new BindingException("Can not determine children set method for: "+parentElement.getClass().getName()); //$NON-NLS-1$

	Method setter = setters[0];
	Class[] parameters = setter.getParameterTypes();
	Object arg;
	if (parameters[0].isArray())
	arg = children;
	else
	arg = Arrays.asList(children);
	try {
	setter.invoke(parentElement, new Object[] { arg } );
	} catch (IllegalArgumentException e) {
	throw new BindingException(e.getLocalizedMessage());
	} catch (IllegalAccessException e) {
	throw new BindingException(e.getLocalizedMessage());
	} catch (InvocationTargetException e) {
	throw new BindingException(e.getLocalizedMessage());
	}
	hookup(parentElement, children);
	if (changeSupport!=null)
	changeSupport.fireTreeChange(ChangeEvent.REPLACE, null, children, parentElement, -1);
	}

	public boolean hasChildren(Object element) {
	Object[] children = getChildren(element);
	return (children!=null && children.length>0);
	}

	public Class[] getTypes() {
	return modelDescription.getTypes();
	}

	public void addTreeChangeListener(IChangeListener listener) {
	if (listener==null)
	return;
	if (changeSupport==null)
	changeSupport = new ITree.ChangeSupport(this);
	changeSupport.addTreeChangeListener(listener);
	}

	public void removeTreeChangeListener(IChangeListener listener) {
	if (listener==null \|\| changeSupport==null)
	return;

	changeSupport.removeTreeChangeListener(listener);
	}

	public void dispose() {
	if (listenerSupport!=null) {
	for (Iterator itr=listenerSupport.values().iterator(); itr.hasNext();)
	((ListenerSupport)itr.next()).dispose();
	listenerSupport=null;
	descriptors=null;
	changeSupport=null;
	modelDescription=null;
	}
	}



	}