net.sf.javagimmicks.swing.model.ListTreeModel Maven / Gradle / Ivy

Go to download
package net.sf.javagimmicks.swing.model;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

import javax.swing.event.TreeModelEvent;
import javax.swing.event.TreeModelListener;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;

public class ListTreeModel implements TreeModel
{
	protected final List _listeners = new ArrayList();
	protected final boolean _noChildrenMeansLeaf;
	
	protected ListTreeNode _root;
	
	public ListTreeModel(boolean noChildrenMeansLeaf)
	{
		_noChildrenMeansLeaf = noChildrenMeansLeaf;
	}
	
	public ListTreeModel()
	{
		this(false);
	}
	
	public ListTreeNode createRoot(E value)
	{
		if(_root != null)
		{
			throw new IllegalStateException("The model already has a root!");
		}
		
		_root = new ListTreeNode(this, false, value);
		
		return _root;
	}
	
	public ListTreeNode clear()
	{
		if(_root == null)
		{
			return null;
		}
		else
		{
			ListTreeNode result = _root;
			
			_root.updateModel(null);
			
			return result;
		}
	}
	
	public Object getChild(Object parent, int index)
	{
		ListTreeNode simpleTreeNode = checkAndConvertToNode(parent);
		
		return simpleTreeNode.getChildAt(index);
	}

	public int getChildCount(Object parent)
	{
		ListTreeNode simpleTreeNode = checkAndConvertToNode(parent);
		
		return simpleTreeNode.getChildCount();
	}

	public int getIndexOfChild(Object parent, Object child)
	{
		ListTreeNode simpleTreeNode = checkAndConvertToNode(parent);
		
		return simpleTreeNode.getChildListView().indexOf(child);
	}

	public Object getRoot()
	{
		return _root;
	}

	public boolean isLeaf(Object node)
	{
		ListTreeNode simpleTreeNode = checkAndConvertToNode(node);
		
		return _noChildrenMeansLeaf ? simpleTreeNode.getChildCount() == 0 : !simpleTreeNode.getAllowsChildren();
	}
	
	public void addTreeModelListener(TreeModelListener listener)
	{
		_listeners.add(listener);
	}

	public void removeTreeModelListener(TreeModelListener listener)
	{
		_listeners.remove(listener);
	}

	@SuppressWarnings("unchecked")
	public void valueForPathChanged(TreePath path, Object newValue)
	{
		Object node = path.getLastPathComponent();
		ListTreeNode simpleTreeNode = checkAndConvertToNode(node);

		simpleTreeNode.setValue((E)newValue);
	}
	
	@SuppressWarnings("unchecked")
	public List> getPathToRootList(ListTreeNode node)
	{
		if(node == null || node._model != this)
		{
			return Collections.EMPTY_LIST;
		}

		LinkedList> result = new LinkedList>();
		
		while(node != null)
		{
			result.addFirst(node);
			node = node._parent;
		}
		
		return result;
	}
	
	public TreePath getPathToRoot(ListTreeNode node)
	{
		return new TreePath(getPathToRootList(node).toArray());
	}
	
	protected void fireNodeChanged(ListTreeNode parent, int index)
	{
		TreeModelEvent event = createTreeModelEvent(parent, index);
		
		for(TreeModelListener listener : _listeners)
		{
			listener.treeNodesChanged(event);
		}
	}
	
	protected void fireNodesInserted(ListTreeNode parent, int fromIndex, Collection> nodes)
	{
		TreeModelEvent event = createTreeModelEvent(parent, fromIndex, nodes);

		for(TreeModelListener listener : _listeners)
		{
			listener.treeNodesInserted(event);
		}
	}
	
	protected void fireNodesRemoved(ListTreeNode parent, int index, Collection> nodes)
	{
		TreeModelEvent event = createTreeModelEvent(parent, index, nodes);
		
		for(TreeModelListener listener : _listeners)
		{
			listener.treeNodesRemoved(event);
		}
	}
	
	protected TreeModelEvent createTreeModelEvent(ListTreeNode parent, int index)
	{
		return new TreeModelEvent(this, getPathToRoot(parent), new int[]{index}, new Object[]{parent._children.get(index)}); 
	}
	
	protected TreeModelEvent createTreeModelEvent(ListTreeNode parent, int fromIndex, Collection> nodes)
	{
		int[] indices = new int[nodes.size()];
		for(int i = 0; i < indices.length; ++i)
		{
			indices[i] = fromIndex + i;
		}
		
		return new TreeModelEvent(this, getPathToRoot(parent), indices, nodes.toArray()); 
	}

	@SuppressWarnings("unchecked")
	private ListTreeNode checkAndConvertToNode(Object o)
	{
		if(!(o instanceof ListTreeNode))
		{
			throw new IllegalArgumentException("Provided node must be of type " + ListTreeNode.class.getName());
		}
		
		ListTreeNode simpleTreeNode = (ListTreeNode)o;
		
		if(simpleTreeNode._model != this)
		{
			throw new IllegalArgumentException("Provided node is not contained in this model");
		}
		
		return simpleTreeNode;
	}

}