/* ----------------------------------------------------------------------------
   The Kiwi Toolkit - A Java Class Library
   Copyright (C) 1998-2004 Mark A. Lindner

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 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
   General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this library; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
   02111-1307, USA.
 
   The author may be contacted at: mark_a_lindner@yahoo.com
   ----------------------------------------------------------------------------
   $Log: DefaultKTreeModel.java,v $
   Revision 1.1  2004/05/31 07:30:26  markl
   Final cleanup and bugfixes of kiwi.ui.model.

   ----------------------------------------------------------------------------
*/

package kiwi.ui.model;

import java.awt.Image;
import java.lang.reflect.Method;
import java.util.*;
import javax.swing.Icon;

import kiwi.event.*;
import kiwi.util.*;

/** A default implementation of <code>KTreeModel</code>.
  *
  * @author Mark Lindner
  * @since Kiwi 2.0
  */

public class DefaultKTreeModel implements KTreeModel
  {
  private Vector listeners = new Vector();
  /** The object-to-node map. */
  protected TreeMap nodeMap;
  protected KTreeModelSupport support;
  protected static final TreeNode emptyList[] = new TreeNode[0];

  private static final Icon FOLDER_OPEN_ICON = KiwiUtils.getResourceManager()
    .getIcon("folder-open.gif");
  private static final Icon FOLDER_CLOSED_ICON = KiwiUtils.getResourceManager()
    .getIcon("folder-closed.gif");
  private static final Icon DOCUMENT_ICON = KiwiUtils.getResourceManager()
    .getIcon("document.gif");

  /** The model's root node. */
  protected TreeNode rootNode;

  /** Construct a new, static <code>DefaultKTreeModel</code>. */

  public DefaultKTreeModel()
    {
    support = new KTreeModelSupport(this);
    nodeMap = new TreeMap(new HashCodeComparator());
    }

  /** Create a node for an object. This method is provided for
   * subclasses which maintain dynamic tree data.
   */

  protected TreeNode makeNode(Object object, TreeNode parent)
    {
    TreeNode node = new TreeNode(object, parent);
    nodeMap.put(object, node);
    
    return(node);
    }

  /** Destroy a node, and recursively destroy all its descendants. This method
   * is provided for subclasses which maintain dynamic tree data.
   */
  
  protected void destroyNode(TreeNode node)
    {
    Iterator iter = node.getChildren();
    if(iter != null)
      while(iter.hasNext())
        {
        destroyNode((TreeNode)iter.next());
        }

    nodeMap.remove(node.getObject());
    }

  /*
   */

  public synchronized Object getRoot()
    {
    return(rootNode == null ? null : rootNode.getObject());
    }

  /*
   */

  public synchronized void setRoot(Object root)
    {
    nodeMap.clear();
    
    rootNode = makeNode(root, null);
    support.fireDataChanged();
    }

  /*
   */
  
  public synchronized int getChildCount(Object node)
    {
    TreeNode n = nodeForObject(node);
    return(n.getChildCount());
    }

  /*
   */
  
  public synchronized Object getChild(Object parent, int index)
    {
    TreeNode p = nodeForObject(parent);
    if(p == null)
      return(null);

    TreeNode child = p.getChild(index);
    if(child == null)
      return(null);

    return(child.getObject());
    }

  /*
   */
  
  public synchronized Iterator getChildren(Object parent)
    {
    TreeNode p = nodeForObject(parent);
    if(p == null)
      return(null);

    Iterator iter = p.getChildren();
    ArrayList list = new ArrayList();
    while(iter.hasNext())
      {
      TreeNode node = (TreeNode)iter.next();
      list.add(node.getObject());
      }
    
    return(list.iterator());
    }

  /*
   */

  public synchronized int getIndexOfChild(Object parent, Object node)
    {
    TreeNode p = nodeForObject(parent);
    if(p == null)
      return(-1);

    TreeNode child = nodeForObject(node);

    return((child == null) ? -1 : p.getIndexOfChild(child));
    }

  /*
   */

  public synchronized void removeChildren(Object parent)
    {
    TreeNode p = nodeForObject(parent);
    if(p != null)
      p.removeChildren();
    }

  /*
   */

  public synchronized void removeChild(Object parent, int index)
    {
    TreeNode p = nodeForObject(parent);
    if(p != null)
      p.removeChild(index);
    }

  /*
   */

  public synchronized void addChild(Object parent, Object node)
    {
    TreeNode p = nodeForObject(parent);
    if(p != null)
      p.addChild(makeNode(node, p));
    }

  /*
   */

  public synchronized void addChild(Object parent, Object node, int index)
    {
    TreeNode p = nodeForObject(parent);
    if(p != null)
      p.addChild(makeNode(node, p), index);
    }

  /*
   */

  public synchronized Object getParent(Object node)
    {
    TreeNode n = nodeForObject(node);
    if(n == null)
      return(null);

    TreeNode p = n.getParent();

    return((p == null) ? null : p.getObject());
    }

  /*
   */

  public synchronized boolean isExpandable(Object node)
    {
    TreeNode n = nodeForObject(node);

    return((n == null) ? false : n.isExpandable());
    }
  
  /** May be overridden by subclasses to provide custom icons.
   */

  public synchronized Icon getIcon(Object node, boolean isExpanded)
    {
    if(isExpandable(node))
      return(isExpanded ? FOLDER_OPEN_ICON : FOLDER_CLOSED_ICON);
    else
      return(DOCUMENT_ICON);
    }

  /** May be overridden by subclasses to provide custom labels.
   */

  public synchronized String getLabel(Object node)
    {
    return(node.toString());
    }

  /*
   */

  public synchronized void updateNode(Object node)
    {
    TreeNode n = nodeForObject(node);
    
    if(n != null)
      {
      TreeNode parent = n.getParent();
      int index = n.getIndexOfChild(n);
      if(index >= 0)
        support.fireNodeChanged(parent.getObject(), index);
      }
    }

  /*
   */

  public synchronized void updateChildren(Object parent)
    {
    TreeNode p = nodeForObject(parent);
    if(p != null)
      support.fireNodeStructureChanged(parent);
    }

  /*
   */

  public synchronized void releaseChildren(Object parent)
    {
    /* no-op */
    }

  /** Get the value of an arbitrary property for a given node.
    *
    * @param node The node.
    * @param property The name of the property.
    *
    * @return The value of the specified property, or <code>null</code> if
    * there is no value for this property.
   */

  public Object getValueForProperty(Object node, String property)
    {
    return(null);
    }

  /*
   */

  /** Add a <code>TreeModelListener</code> to this model's list of listeners.
    *
    * @param listener The listener to be added.
    * @see #removeTreeModelListener
    */

  public void addTreeModelListener(KTreeModelListener listener)
    {
    support.addTreeModelListener(listener);
    }
        
  /** Remove a <code>TreeModelListener</code> from this model's list of
   * listeners.
   *
   * @param listener The listener to remove.
   * @see #addTreeModelListener
   */

  public void removeTreeModelListener(KTreeModelListener listener)
    {
    support.removeTreeModelListener(listener);
    }

  /** Look up a node for a given object.
   */

  protected TreeNode nodeForObject(Object item)
    {
    return((TreeNode)nodeMap.get(item));
    }

  /*
   */

  public void preloadChildren(Object item)
    {
    TreeNode node = (TreeNode)nodeMap.get(item);
    if(node != null)
      {
      if(! node.hasChildrenLoaded())
        loadChildren(node);
      }
    }
  
  /** Load the children for a given node. This method is provided for
   * subclasses which obtain tree data from an external source. The default
   * implementation is a no-op.
   *
   * @param node The parent node.
   */

  protected void loadChildren(TreeNode node)
    {
    /* in this case, a no-op */
    }

  /** Internal wrapper object for nodes. */

  protected class TreeNode
    {
    private Object object;
    private TreeNode parent;
    private ArrayList children = null; // null if not yet loaded
    private boolean expandable = false;
    private int childCount = 0;
    
    /* construct a new tree node */

    TreeNode(Object object, TreeNode parent)
      {
      this.parent = parent;
      this.object = object;
      }

    /* get the index of the given child in the list of children */

    int getIndexOfChild(TreeNode child)
      {
      if(children == null)
        return(-1);
      
      return(children.indexOf(child));
      }

    /* add a new child to the list of children */

    void addChild(TreeNode child)
      {
      if(children == null)
        children = new ArrayList();
      
      int ct = children.size();
      children.add(child);
      support.fireNodeAdded(object, ct);
      }

    /* insert a given child at the given position in the list of children */

    void addChild(TreeNode child, int index)
      {
      if(index < 0)
        index = 0;
      else if(index > children.size())
        index = children.size();
      
      children.add(index, child);
      support.fireNodeAdded(object, index);
      }

    /* replace the children with a new list of children */

    void setChildren(ArrayList children)
      {
      this.children = children;
      support.fireNodeStructureChanged(object);
      }
    
    /* remove a child from the list of children */

    void removeChild(TreeNode child)
      {
      int index = children.indexOf(child);
      if(index >= 0 || index < children.size())
        {
        children.remove(index);
        destroyNode(child);
        support.fireNodeRemoved(object, index);
        }
      }

    /* */
    
    void removeChildren()
      {
      int ct = children.size();
      if(ct > 0)
        {
        Iterator iter = children.iterator();
        while(iter.hasNext())
          destroyNode((TreeNode)iter.next());
        
        children.clear();
        support.fireNodesRemoved(object, 0, --ct);
        }
      }

    /* remove the child at the given position in the list of children */

    void removeChild(int index)
      {
      TreeNode node = (TreeNode)children.get(index);
      destroyNode(node);
      children.remove(index);
      support.fireNodeRemoved(object, index);
      }

    /* drop the children */

    void releaseChildren()
      {
      if(children == null)
        return;
      
      Iterator iter = children.iterator();
      while(iter.hasNext())
        destroyNode((TreeNode)iter.next());

      children = null;
      }

    /* get the user object for this node */

    Object getObject()
      {
      return(object);
      }

    /* set the expandable flag */

    void setExpandable(boolean flag)
      {
      expandable = flag;
      }

    /* determine if this node is expandable */

    public boolean isExpandable()
      {
      return(expandable);
      }

    /* get the parent of this node */

    public TreeNode getParent()
      {
      return(parent);
      }

    /* get a child count for the node */
    
    int getChildCount()
      {
      // We need to remember the (most recent) child count even after
      // the children are dropped; otherwise we'd report child count
      // of 0 and the tree would render the parent without an expander
      // control.
      
      if(children != null)
        childCount = children.size();

      return(childCount);
      }

    /* get the child at a given index */
    
    TreeNode getChild(int index)
      {
      return((children == null) ? null : (TreeNode)children.get(index));
      }

    /* get an iterator to the children */

    Iterator getChildren()
      {
      return((children == null) ? null : children.iterator());
      }

    /* are children loaded? */

    boolean hasChildrenLoaded()
      {
      return(children != null);
      }

    }
  }

/* end of source file */