/*
Wotonomy: OpenStep design patterns for pure Java applications.
Copyright (C) 2001 Intersect Software Corporation

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, see http://www.gnu.org
*/

package net.wotonomy.ui.swing;

import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;

import javax.swing.JTree;
import javax.swing.tree.MutableTreeNode;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;

import net.wotonomy.foundation.internal.WotonomyException;
import net.wotonomy.ui.EODisplayGroup;

/**
 * A DisplayGroupNode that exposes the MutableTreeNode interface. This was
 * required so that other subclasses of DisplayGroupNode could opt out of
 * supporting MutableTreeNode (so that they can implement IlvActivity, for
 * example).
 *
 * @author michael@mpowers.net
 * @author $Author: cgruber $
 * @version $Revision: 904 $
 */
public class MutableDisplayGroupNode extends DisplayGroupNode implements MutableTreeNode {
	/**
	 * Constructor for all nodes. Root node must have a null delegate.
	 */
	public MutableDisplayGroupNode(TreeModelAssociation aParentAssociation, EODisplayGroup aParentGroup,
			Object anObject) {
		super(aParentAssociation, aParentGroup, anObject);
	}

	public int getIndex(TreeNode node) {
		return getIndex((DisplayGroupNode) node);
	}

	public TreeNode getChildAt(int childIndex) {
		return (TreeNode) getChildNodeAt(childIndex);
	}

	public TreeNode getParent() {
		Object parent = getParentGroup();
		if (parent instanceof TreeNode) {
			return (TreeNode) parent;
		}
		return null;
	}

	public void insert(MutableTreeNode aChild, int anIndex) {
		if (aChild instanceof DisplayGroupNode) {
			insertObjectAtIndex(((DisplayGroupNode) aChild).object(), anIndex);
		} else // not a display group node
		{
			throw new WotonomyException("Cannot insert nodes of type: " + aChild);
		}
	}

	/**
	 * Removes the node at the index corresponding to the index of the object.
	 */
	public void remove(MutableTreeNode node) {
		if (node instanceof DisplayGroupNode) {
			remove((DisplayGroupNode) node);
		} else // not a display group node
		{
			throw new WotonomyException("Cannot insert nodes of type: " + node);
		}
	}

	/**
	 * Removes the value in the parent display group at the index that corresponds
	 * to the index of this node and add it to the end of the display group that
	 * corresponds to the user value of the specified node.
	 */
	public void setParent(MutableTreeNode newParent) {
		if (newParent instanceof DisplayGroupNode) {
			setParent((DisplayGroupNode) newParent);
		} else // not a display group node
		{
			throw new WotonomyException("Cannot set parent to nodes of type: " + newParent);
		}
	}

	/**
	 * Overridden to remember expanded state for nodes after nodes have been
	 * rearranged.
	 */
	protected void fireEventsForChanges(Object[] oldObjects, Object[] newObjects) {
		if (!(parentAssociation.object() instanceof JTree)) {
			super.fireEventsForChanges(oldObjects, newObjects);
			return;
		}

		JTree tree = (JTree) parentAssociation.object();
		Map expansionMap = new HashMap();
		DisplayGroupNode node;
		TreePath path;
		for (int i = 0; i < oldObjects.length; i++) {
			node = (DisplayGroupNode) getChildNodeForObject(oldObjects[i]);
			if (node != null && !node.isLeaf()) {
				expansionMap.put(node, new Boolean(tree.isExpanded(node.treePath())));
			}
		}

		super.fireEventsForChanges(oldObjects, newObjects);

		Object value;
		Iterator iterator = new LinkedList(childNodes.values()).iterator();
		while (iterator.hasNext()) {
			node = (DisplayGroupNode) iterator.next();
			value = expansionMap.get(node);
			if (value != null) {
				if (Boolean.TRUE.equals(value)) {
					tree.expandPath(node.treePath());
				} else {
					tree.collapsePath(node.treePath());
				}
			}
		}
	}
}
/*
 * $Log$ Revision 1.2 2006/02/18 23:19:05 cgruber Update imports and maven
 * dependencies.
 *
 * Revision 1.1 2006/02/16 13:22:22 cgruber Check in all sources in
 * eclipse-friendly maven-enabled packages.
 *
 * Revision 1.8 2003/08/06 23:07:52 chochos general code cleanup (mostly,
 * removing unused imports)
 *
 * Revision 1.7 2002/04/23 19:12:28 mpowers Reimplemented fireEventsForChanges.
 * Fitter and happier.
 *
 * Revision 1.6 2002/04/10 21:20:04 mpowers Better handling for tree nodes when
 * working with editing contexts. Better handling for invalidation. No longer
 * broadcasting events when nodes have not been "registered" in the tree.
 *
 * Revision 1.5 2002/04/03 20:01:47 mpowers Now remembers expanded state.
 *
 * Revision 1.4 2002/03/08 23:19:07 mpowers Added getParentGroup to
 * DisplayGroupNode.
 *
 * Revision 1.3 2002/02/27 23:19:17 mpowers Refactoring of TreeAssociation to
 * create TreeModelAssociation parent.
 *
 * Revision 1.2 2001/04/22 23:05:33 mpowers Totally revised DisplayGroupNode so
 * each object gets its own node (so the nodes are no longer fixed by index).
 *
 * Revision 1.1 2001/04/21 23:05:56 mpowers Contributing the tree-specific
 * concrete subclass of DisplayGroupNode.
 *
 *
 */