/* -------------------------------------------------------------------
    * Java source file for the class BranchGroup
    * 
    * Copyright (c), 2003, Masahiro Takatsuka.
    * All Rights Researved.
    * 
    * Original Author: Masahiro Takatsuka (masa@jbeans.net)
    * $Author: takatsukam $
    * 
   * $Date: 2004/03/03 11:53:06 $
   * 
   * $Id: BranchGroup.java,v 1.3 2004/03/03 11:53:06 takatsukam Exp $
   * 
   * Reference:		Document no:
   * ___				___
   * 
   * To Do:
   * ___
   * 
  ------------------------------------------------------------------- */
  
  /* --------------------------- Package ---------------------------- */
  package net.jbeans.j3d.scenegraph;
  
  /* ------------------ Import classes (packages) ------------------- *//package-summary/html">class="comment"> ------------------ Import classes (packages) ------------------- *//package-summary.html">class="comment">/* ------------------ Import classes (packages) ------------------- *//package-summary.html">class="comment"> ------------------ Import classes (packages) ------------------- */
  import java.io.*;
  import java.util.*;
  import javax.swing.event.*;
  import javax.media.j3d.Group;
  import javax.media.j3d.Node;
  
  import net.jbeans.j3d.event.*;
  import net.jbeans.util.*;
  import net.jbeans.util.debug.*;
  
  /*====================================================================
                   Implementation of class BranchGroup                  
  ====================================================================*/
  /***
   * generally describe BranchGroup in here
   * 
   * @version $Revision: 1.3 $
   * @author Masahiro Takatsuka (masa@jbeans.net)
   * @see javax.media.j3d.BranchGroup
   * @see Serializable
   */
  
  public class BranchGroup extends javax.media.j3d.BranchGroup implements Serializable {
  	private static final boolean DEBUG = Debug.getDebugFlag(BranchGroup.class);
  
  	
  	/* ------------------------ not serialized ------------------------ */
  	transient private EventListenerList sceneGraphObjectListeners;
  	transient private EventObject myEvent;
  	
  	public BranchGroup () {
  		super();
  		initialize();
  	}
  
  	private final void initialize() {
  		this.sceneGraphObjectListeners = new EventListenerList();
  		this.myEvent = new EventObject(this);
  		setCapabilities();
  	}
  
  	public void setUserData(Object userData) {
  		if (userData instanceof BranchGroup) {
  			BranchGroup bg = (BranchGroup) userData;
  			if (DEBUG) {
  				System.out.println("BranchGroup:numChildren of userData = " + bg.numChildren());
  			}
  			if (bg.numChildren() == 0) {
  				// ignore this!
  				return;
  			}
  		}
  		super.setUserData(userData);
  	}
  
  	private final void setCapabilities() {
  		setCapability(ALLOW_DETACH);
  		setCapability(Group.ALLOW_CHILDREN_EXTEND);
  		setCapability(Group.ALLOW_CHILDREN_READ);
  		setCapability(Group.ALLOW_CHILDREN_WRITE);
  		setCapability(Group.ALLOW_COLLISION_BOUNDS_READ);
  		setCapability(Group.ALLOW_COLLISION_BOUNDS_WRITE);		
  		setCapability(Node.ALLOW_AUTO_COMPUTE_BOUNDS_READ);
  		setCapability(Node.ALLOW_AUTO_COMPUTE_BOUNDS_WRITE);		
  		setCapability(Node.ALLOW_BOUNDS_READ);
  		setCapability(Node.ALLOW_BOUNDS_WRITE);		
  		setCapability(Node.ALLOW_COLLIDABLE_READ);
  		setCapability(Node.ALLOW_COLLIDABLE_WRITE);		
  		setCapability(Node.ALLOW_PICKABLE_READ);
  		setCapability(Node.ALLOW_PICKABLE_WRITE);
  
  		setBoundsAutoCompute(true);
  	}
  	
 	public void addChild(Object child) {
 		if (child instanceof Node) {
 			addChild((Node) child);
 		} else if (ArrayUtil.isArray(child)) {
 			Object[] childs = (Object[]) child;
 			int num = childs.length;
 			for (int i = 0; i < num; i++) {
 				addChild((Object) childs[i]);
 			}
 		}
 	}
 
 	public void addChild(Node child) {
 		try {
 			Node childParent = child.getParent();
 			if (childParent != null) { // already a part of a scenegraph!
 				// don't do anything, just return;
 				if (DEBUG) {
 					System.out.println("BranchGroup.addChild() : it already has a parent");
 				}
 			} else {
 				if (child instanceof BranchGroup) {
 					if (DEBUG) {
 						System.out.println("BranchGroup: adding BranchGroup");
 					}
 					super.addChild(child);
 				} else {
 					Object parent = getUserData();
 					if ((parent != null) &&
 						(parent instanceof Group)) {
 						// detach "this" from the scenegraph first
 						detach();
 						// then add a child
 						if (DEBUG) {
 							System.out.println("BranchGroup: adding Node (parent)");
 						}
 						super.addChild(child);
 						((Group) parent).addChild(this);
 					} else {
 						if (DEBUG) {
 							System.out.println("BranchGroup: adding Node = " + child);
 						}
 						super.addChild(child);
 					}
 				}
 			}
 		} catch (Exception e) {
 			if (DEBUG) {
 				e.printStackTrace();
 			}
 			// already a part of a scenegraph
 			// don't do anything, just return
 		}
 		fireSceneGraphObjectChanged();
 	}
 	
 	/***
 	 *
 	 */
 	public void removeChild(Node child) {
 		/*
 		 * I could use Enumerator to go throgh all child but
 		 * direct access might be faster..
 		 */
 		int allCnt = numChildren();
 		int i = -1;
 		for (i = 0; i < allCnt; i++) {
 			if (child.equals(getChild(i))) {
 				Object parent = getUserData();
 				if ((parent != null) &&
 					(parent instanceof Group)) {
 					// detach "this" from the scenegraph first
 					detach();
 					// then remove a child
 					removeChild(i);
 					// then re atach "this" to the scenegraph.
 					((Group) parent).addChild(this);
 				}
 				return;
 			}
 		}
 		/*
 		 * this method does not have to fire fireSceneGraphObjectChanged()
 		 */
 	}
 
 	/***
      * adds an SceneGraphObjectListener to the shape.
 	 * There should be only one listener, which is the parent of
 	 * this BranchGroup.
      */
     public void addSceneGraphObjectListener(SceneGraphObjectListener l) {
         this.sceneGraphObjectListeners.add(SceneGraphObjectListener.class, l);
     }
 
     /***
      * removes an SceneGraphObjectListener from the branchGroup.
      */
     public void removeSceneGraphObjectListener(SceneGraphObjectListener l) {
 		this.sceneGraphObjectListeners.remove(SceneGraphObjectListener.class, l);
 		/*
 		* This code is no longer used since BranchGroup is added to
 		* J3DRenderer using "self" connector.
 		* Masahiro Takatsuka/2001-Jul-14
 		*/
 
 		/* the lister "l" might have a reference of this object.
 		   so, remove it!
 		*/
 //  		if (l instanceof Proxy) {
 //  			InvocationHandler handler = Proxy.getInvocationHandler(l);
 //  			Object target = AdapterHandler.getTarget(handler);
 //  			if (DEBUG) {
 //  				System.out.println("target = " + target);
 //  			}
 //  			if (target != null) {
 //  				try {
 //  					Object[] args = {this};
 //  					Class[] argTypes = {BranchGroup.class};
 //  					ClassUtil.makeObjectPerform(target, "detachBranchGraph", args, argTypes);
 //  				} catch (Exception e) {
 //  					if (DEBUG) {
 //  						e.printStackTrace();
 //  					}
 //  				}
 //  			}
 //  		}
     }
 
     /***
      * Notify all listeners that have registered interest for
      * notification on this event type.
      */
     public void fireSceneGraphObjectChanged() {
         Object[] listeners = this.sceneGraphObjectListeners.getListenerList();
         // Process the listeners last to first, notifying
         // those that are interested in this event
         for (int i = listeners.length - 2; i >= 0; i -= 2) {
             if (listeners[i] == SceneGraphObjectListener.class) {
                 // Lazily create the event:
                 ((SceneGraphObjectListener)listeners[i+1]).objectChanged(this.myEvent);
             }
         }
     }
 
     /***
      * Serialization methods
      */
     private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException {
 		initialize();
     }
 }