j3dcore: flatten the directory structure a bit

Signed-off-by: Harvey Harrison <[email protected]>

1 files changed, 555 insertions, 0 deletions

diff --git a/src/javax/media/j3d/Group.java b/src/javax/media/j3d/Group.java
new file mode 100644
index 0000000..11dee57
--- /dev/null
+++ b/src/javax/media/j3d/Group.java
@@ -0,0 +1,555 @@
+/*
+ * Copyright 1996-2008 Sun Microsystems, Inc.  All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+package javax.media.j3d;
+
+import java.util.Enumeration;
+import java.util.Hashtable;
+
+/**
+ * The Group node object is a general-purpose grouping node. Group
+ * nodes have exactly one parent and an arbitrary number of children
+ * that are rendered in an unspecified order (or in parallel).  Null
+ * children are allowed; no operation is performed on a null child
+ * node.  Operations on Group node objects include adding, removing,
+ * and enumerating the children of the Group node. The subclasses of
+ * Group node add additional semantics.
+ */
+
+public class Group extends Node {
+    /**
+     * Specifies that this Group node allows reading its children.
+     */
+    public static final int
+    ALLOW_CHILDREN_READ = CapabilityBits.GROUP_ALLOW_CHILDREN_READ;
+
+    /**
+     * Specifies that this Group node allows writing its children.
+     */
+    public static final int
+    ALLOW_CHILDREN_WRITE = CapabilityBits.GROUP_ALLOW_CHILDREN_WRITE;
+
+    /**
+     * Specifies that this Group node allows adding new children.
+     */
+    public static final int
+    ALLOW_CHILDREN_EXTEND = CapabilityBits.GROUP_ALLOW_CHILDREN_EXTEND;
+
+    /**
+     * Specifies that this Group node allows reading its collision Bounds
+     */
+    public static final int
+    ALLOW_COLLISION_BOUNDS_READ =
+        CapabilityBits.GROUP_ALLOW_COLLISION_BOUNDS_READ;
+
+    /**
+     * Specifies that this Group node allows writing its collision Bounds
+     */
+    public static final int
+    ALLOW_COLLISION_BOUNDS_WRITE =
+        CapabilityBits.GROUP_ALLOW_COLLISION_BOUNDS_WRITE;
+
+    // Array for setting default read capabilities
+    private static final int[] readCapabilities = {
+        ALLOW_CHILDREN_READ,
+        ALLOW_COLLISION_BOUNDS_READ
+    };
+
+
+    /**
+     * Creates the retained mode GroupRetained object that this
+     * Group component object will point to.
+     */
+    @Override
+    void createRetained() {
+	retained = new GroupRetained();
+	retained.setSource(this);
+    }
+
+
+    /**
+      * Sets the collision bounds of a node.
+      * @param bounds the collision bounding object for a node
+      * @exception CapabilityNotSetException if appropriate capability is
+      * not set and this object is part of live or compiled scene graph
+      */
+    public void setCollisionBounds(Bounds bounds) {
+	if (isLiveOrCompiled())
+	    if(!this.getCapability(ALLOW_COLLISION_BOUNDS_WRITE))
+		throw new CapabilityNotSetException(J3dI18N.getString("Group0"));
+
+	((GroupRetained)this.retained).setCollisionBounds(bounds);
+    }
+
+    /**
+      * Returns the collision bounding object of this node.
+      * @return the node's collision bounding object
+      * @exception CapabilityNotSetException if appropriate capability is
+      * not set and this object is part of live or compiled scene graph
+      */
+    public Bounds getCollisionBounds() {
+	if (isLiveOrCompiled())
+	    if(!this.getCapability(ALLOW_COLLISION_BOUNDS_READ))
+		throw new CapabilityNotSetException(J3dI18N.getString("Group1"));
+
+	return ((GroupRetained)this.retained).getCollisionBounds();
+    }
+
+    /**
+     * Replaces the child node at the specified index in this
+     * group node's list of children with the specified child.
+     * @param child the new child
+     * @param index which child to replace.  The <code>index</code> must
+     * be a value
+     * greater than or equal to 0 and less than <code>numChildren()</code>.
+     * @exception CapabilityNotSetException if the appropriate capability is
+     * not set and this group node is part of live or compiled scene graph
+     * @exception RestrictedAccessException if this group node is part of
+     * live or compiled scene graph and the child node being set is not
+     * a BranchGroup node
+     * @exception MultipleParentException if <code>child</code> has already
+     * been added as a child of another group node
+     * @exception IndexOutOfBoundsException if <code>index</code> is invalid
+     */
+    public void setChild(Node child, int index) {
+	if (child instanceof SharedGroup) {
+	    throw new IllegalArgumentException(J3dI18N.getString("Group2"));
+	}
+
+	if (isLiveOrCompiled()) {
+	    Node oldchild =
+                (Node) ((GroupRetained)this.retained).getChild(index);
+	    if (! (child instanceof BranchGroup))
+		throw new RestrictedAccessException(J3dI18N.getString("Group3"));
+
+	    if (!getCapability(ALLOW_CHILDREN_WRITE))
+		throw new CapabilityNotSetException(J3dI18N.getString("Group13"));
+
+	    if ((oldchild != null) &&
+		(! ((BranchGroup)oldchild).getCapability(BranchGroup.ALLOW_DETACH))) {
+		throw new CapabilityNotSetException(J3dI18N.getString("Group4"));
+	    }
+	}
+
+	((GroupRetained)retained).setChild(child, index);
+    }
+
+    /**
+     * Inserts the specified child node in this group node's list of
+     * children at the specified index.
+     * @param child the new child
+     * @param index at which location to insert. The <code>index</code>
+     * must be a value
+     * greater than or equal to 0 and less than or equal to
+     * <code>numChildren()</code>.
+     * @exception CapabilityNotSetException if the appropriate capability is
+     * not set and this group node is part of live or compiled scene graph
+     * @exception RestrictedAccessException if this group node is part of
+     * live
+     * or compiled scene graph and the child node being inserted is not
+     * a BranchGroup node
+     * @exception MultipleParentException if <code>child</code> has already
+     * been added as a child of another group node.
+     * @exception IndexOutOfBoundsException if <code>index</code> is invalid.
+     */
+    public void insertChild(Node child, int index) {
+	if (child instanceof SharedGroup) {
+	    throw new IllegalArgumentException(J3dI18N.getString("Group2"));
+	}
+
+	if (isLiveOrCompiled()) {
+	    if (! (child instanceof BranchGroup))
+		throw new RestrictedAccessException(J3dI18N.getString("Group6"));
+
+	    if (!this.getCapability(ALLOW_CHILDREN_WRITE))
+		throw new CapabilityNotSetException(J3dI18N.getString("Group14"));
+	}
+
+	((GroupRetained)this.retained).insertChild(child, index);
+    }
+
+    /**
+     * Removes the child node at the specified index from this group node's
+     * list of children.
+     * @param index which child to remove.  The <code>index</code>
+     * must be a value
+     * greater than or equal to 0 and less than <code>numChildren()</code>.
+     * @exception CapabilityNotSetException if the appropriate capability is
+     * not set and this group node is part of live or compiled scene graph
+     * @exception RestrictedAccessException if this group node is part of
+     * live or compiled scene graph and the child node being removed is not
+     * a BranchGroup node
+     * @exception IndexOutOfBoundsException if <code>index</code> is invalid.
+     */
+    public void removeChild(int index) {
+	if (isLiveOrCompiled()) {
+	    Node child = ((GroupRetained)this.retained).getChild(index);
+	    if (!(child instanceof BranchGroup)) {
+		throw new RestrictedAccessException(J3dI18N.getString("Group7"));
+	    }
+
+	    if (!this.getCapability(ALLOW_CHILDREN_WRITE)) {
+		throw new CapabilityNotSetException(J3dI18N.getString("Group15"));
+	    }
+
+	    if (!((BranchGroup)child).getCapability(BranchGroup.ALLOW_DETACH)) {
+		throw new CapabilityNotSetException(J3dI18N.getString("Group4"));
+	    }
+	}
+
+	((GroupRetained)this.retained).removeChild(index);
+    }
+
+	/**
+	 * Retrieves the child node at the specified index in
+	 * this group node's list of children.
+	 * @param index which child to return.
+	 * @return the children at location index.  The <code>index</code>
+	 * must be a value
+	 * greater than or equal to 0 and less than <code>numChildren()</code>.
+	 * @exception CapabilityNotSetException if the appropriate capability is
+	 * not set and this group node is part of live or compiled scene graph
+	 * @exception IndexOutOfBoundsException if <code>index</code> is invalid.
+	 */
+	public Node getChild(int index) {
+		if (isLiveOrCompiled() && !this.getCapability(ALLOW_CHILDREN_READ))
+			throw new CapabilityNotSetException(J3dI18N.getString("Group9"));
+
+		return ((GroupRetained)this.retained).getChild(index);
+	}
+
+    /**
+     * Returns an Enumeration object of this group node's list of children.
+     * @return an Enumeration object of all the children
+     * @exception CapabilityNotSetException if the appropriate capability is
+     * not set and this group node is part of live or compiled scene graph
+     */
+	public Enumeration<Node> getAllChildren() {
+		if (isLiveOrCompiled() && !this.getCapability(ALLOW_CHILDREN_READ))
+			throw new CapabilityNotSetException(J3dI18N.getString("Group9"));
+
+		return ((GroupRetained)this.retained).getAllChildren();
+	}
+
+    /**
+     * Appends the specified child node to this group node's list of children.
+     * @param child the child to add to this node's list of children
+     * @exception CapabilityNotSetException if the appropriate capability is
+     * not set and this group node is part of live or compiled scene graph
+     * @exception RestrictedAccessException if this group node is part
+     * of live
+     * or compiled scene graph and the child node being added is not
+     * a BranchGroup node
+     * @exception MultipleParentException if <code>child</code> has already
+     * been added as a child of another group node.
+     */
+    public void addChild(Node child) {
+	if (child instanceof SharedGroup) {
+	    throw new IllegalArgumentException(J3dI18N.getString("Group2"));
+	}
+
+	if (isLiveOrCompiled()) {
+	    if (! (child instanceof BranchGroup))
+		throw new RestrictedAccessException(J3dI18N.getString("Group12"));
+
+	    if(!this.getCapability(ALLOW_CHILDREN_EXTEND))
+		throw new CapabilityNotSetException(J3dI18N.getString("Group16"));
+	}
+
+	((GroupRetained)this.retained).addChild(child);
+    }
+
+    /**
+     * Moves the specified branch group node from its existing location to
+     * the end of this group node's list of children.
+     * @param branchGroup the branch group node to move to this node's list
+     * of children
+     * @exception CapabilityNotSetException if the appropriate capability is
+     * not set and this group node is part of live or compiled scene graph
+     */
+    public void moveTo(BranchGroup branchGroup) {
+	if (isLiveOrCompiled()) {
+	    if(!this.getCapability(ALLOW_CHILDREN_EXTEND))
+		throw new CapabilityNotSetException(J3dI18N.getString("Group16"));
+
+	    if (! branchGroup.getCapability(BranchGroup.ALLOW_DETACH)) {
+		throw new CapabilityNotSetException(J3dI18N.getString("Group4"));
+	    }
+	}
+
+	((GroupRetained)this.retained).moveTo(branchGroup);
+    }
+
+    /**
+     * Returns a count of this group node's children.
+     * @return the number of children descendant from this node.
+     * @exception CapabilityNotSetException if the appropriate capability is
+     * not set and this group node is part of live or compiled scene graph
+     */
+    public int numChildren() {
+	if (isLiveOrCompiled())
+	    if(!this.getCapability(ALLOW_CHILDREN_READ))
+		throw new CapabilityNotSetException(J3dI18N.getString("Group9"));
+
+	return ((GroupRetained)this.retained).numChildren();
+    }
+
+
+    /**
+     * Retrieves the index of the specified child node in
+     * this group node's list of children.
+     *
+     * @param child the child node to be looked up.
+     * @return the index of the specified child node;
+     * returns -1 if the object is not in the list.
+     * @exception CapabilityNotSetException if the appropriate capability is
+     * not set and this group node is part of live or compiled scene graph
+     *
+     * @since Java 3D 1.3
+     */
+    public int indexOfChild(Node child) {
+
+	if (isLiveOrCompiled())
+	    if(!this.getCapability(ALLOW_CHILDREN_READ))
+		throw new CapabilityNotSetException(J3dI18N.getString("Group9"));
+
+	return ((GroupRetained)this.retained).indexOfChild(child);
+    }
+
+
+    /**
+     * Removes the specified child node from this group node's
+     * list of children.
+     * If the specified object is not in the list, the list is not modified.
+     *
+     * @param child the child node to be removed.
+     * @exception CapabilityNotSetException if appropriate capability is
+     * not set and this object is part of live or compiled scene graph
+     * @exception RestrictedAccessException if this group node is part of
+     * live or compiled scene graph and the child node being removed is not
+     * a BranchGroup node
+     *
+     * @since Java 3D 1.3
+     */
+    public void removeChild(Node child) {
+
+	if (isLiveOrCompiled()) {
+	    if (!(child instanceof BranchGroup)) {
+		throw new RestrictedAccessException(J3dI18N.getString("Group7"));
+	    }
+
+	    if (!this.getCapability(ALLOW_CHILDREN_WRITE)) {
+		throw new CapabilityNotSetException(J3dI18N.getString("Group15"));
+	    }
+
+	    if (!((BranchGroup)child).getCapability(BranchGroup.ALLOW_DETACH)) {
+		throw new CapabilityNotSetException(J3dI18N.getString("Group4"));
+	    }
+	}
+
+	((GroupRetained)retained).removeChild(child);
+    }
+
+
+    /**
+     * Removes all children from this Group node.
+     *
+     * @exception CapabilityNotSetException if appropriate capability is
+     * not set and this object is part of live or compiled scene graph
+     * @exception RestrictedAccessException if this group node is part of
+     * live or compiled scene graph and any of the children being removed are
+     * not BranchGroup nodes
+     *
+     * @since Java 3D 1.3
+     */
+    public void removeAllChildren() {
+
+	if (isLiveOrCompiled()) {
+	    GroupRetained groupR = (GroupRetained)this.retained;
+	    for (int index = groupR.numChildren() - 1; index >= 0; index--) {
+		Node child = groupR.getChild(index);
+		if (! (child instanceof BranchGroup))
+		    throw new RestrictedAccessException(J3dI18N.getString("Group7"));
+
+		if (!this.getCapability(ALLOW_CHILDREN_WRITE))
+		    throw new CapabilityNotSetException(J3dI18N.getString("Group15"));
+
+		if (!((BranchGroup)child).getCapability(BranchGroup.ALLOW_DETACH)) {
+		    throw new CapabilityNotSetException(J3dI18N.getString("Group4"));
+		}
+	    }
+	}
+
+	((GroupRetained)retained).removeAllChildren();
+    }
+
+
+    /**
+     * Causes this Group node to be reported as the collision target when
+     * collision is being used and this node or any of its children is in
+     * a collision. The default value is false.  For collision with
+     * USE_GEOMETRY set, the collision traverser will check the geometry
+     * of all the Group node's leaf descendants; for collision with
+     * USE_BOUNDS set, the collision traverser will only check the bounds
+     * at this Group node.  In both cases, if there is a collision, this
+     * Group node will be reported as the colliding object in the
+     * SceneGraphPath.  This reporting is done regardless of whether
+     * ENABLE_COLLISION_REPORTING
+     * is set for this group node (setting alternate collision target to
+     * true implies collision reporting).
+     * @param  target  Indicates whether this Group node can be the target
+     * of a collision.
+     * @see WakeupOnCollisionEntry
+     * @see WakeupOnCollisionMovement
+     * @see WakeupOnCollisionExit
+     */
+    public void setAlternateCollisionTarget(boolean target) {
+       ((GroupRetained)this.retained).setAlternateCollisionTarget(target);
+    }
+
+    /**
+      * Returns the collision target state.
+      * @return Indicates whether this Group node can be the target of a
+      * collision.
+      */
+    public boolean getAlternateCollisionTarget() {
+        return ((GroupRetained)this.retained).getAlternateCollisionTarget();
+    }
+
+    /**
+     * Duplicates all the nodes of the specified sub-graph.  For Group Nodes
+     * the group node is duplicated via a call to <code>cloneNode</code> and
+     * then <code>cloneTree</code> is called for each child node.  For
+     * Leaf Nodes, component
+     * data can either be duplicated or be made a reference to the original
+     * data.  Leaf Node cloneTree behavior is determined by the
+     * <code>duplicateOnCloneTree</code> flag found in every Leaf Node's
+     * component data class and by the <code>forceDuplicate</code> paramter.
+     *
+     * @param forceDuplicate when set to <code>true</code>, causes the
+     *  <code>duplicateOnCloneTree</code>
+     *  flag to be ignored.  When <code>false</code>, the value of each
+     *  node's
+     *  <code>duplicateOnCloneTree</code> determines whether data is
+     *  duplicated or copied.
+     *
+     *
+     * @return a reference to the cloned scene graph.
+     *
+     * @see NodeComponent#setDuplicateOnCloneTree
+     */
+    @Override
+    Node cloneTree(boolean forceDuplicate, Hashtable nodeHashtable) {
+        Group g = (Group) super.cloneTree(forceDuplicate, nodeHashtable);
+	GroupRetained rt = (GroupRetained) retained;
+
+        int nChildren = rt.numChildren();
+        // call cloneTree on all child nodes
+        for (int i = 0; i < nChildren; i++) {
+            Node n = rt.getChild(i);
+            Node clonedN = n.cloneTree(forceDuplicate, nodeHashtable);
+            // add the cloned child to the cloned group node
+            ((GroupRetained) g.retained).addChild(clonedN);
+
+        }
+        return g;
+    }
+
+
+
+   /**
+     * Copies all Node information from
+     * <code>originalNode</code> into
+     * the current node.  This method is called from the
+     * <code>cloneNode</code> method which is, in turn, called by the
+     * <code>cloneTree</code> method.<P>
+     *
+     * @param originalNode the original node to duplicate.
+     * @param forceDuplicate when set to <code>true</code>, causes the
+     *  <code>duplicateOnCloneTree</code> flag to be ignored.  When
+     *  <code>false</code>, the value of each node's
+     *  <code>duplicateOnCloneTree</code> variable determines whether
+     *  NodeComponent data is duplicated or copied.
+     *
+     * @exception RestrictedAccessException if this object is part of a live
+     *  or compiled scenegraph.
+     *
+     * @see Node#duplicateNode
+     * @see Node#cloneTree
+     * @see NodeComponent#setDuplicateOnCloneTree
+     */
+    @Override
+    void duplicateAttributes(Node originalNode, boolean forceDuplicate) {
+        super.duplicateAttributes(originalNode, forceDuplicate);
+
+        GroupRetained attr = (GroupRetained) originalNode.retained;
+	GroupRetained rt = (GroupRetained) retained;
+
+	rt.setCollisionBounds(attr.getCollisionBounds());
+	rt.setAlternateCollisionTarget(attr.getAlternateCollisionTarget());
+	// throw away any child create before, since some node such as
+	// Sphere has already created its own branch
+	// Without doing this, we may end up with two branches with exactly
+	// the same content when cloneTree() is invoked.
+	rt.children.clear();
+    }
+
+
+    /**
+     * Used to create a new instance of the node.  This routine is called
+     * by <code>cloneTree</code> to duplicate the current node.
+     * @param forceDuplicate when set to <code>true</code>, causes the
+     *  <code>duplicateOnCloneTree</code> flag to be ignored.  When
+     *  <code>false</code>, the value of each node's
+     *  <code>duplicateOnCloneTree</code> variable determines whether
+     *  NodeComponent data is duplicated or copied.
+     *
+     * @see Node#cloneTree
+     * @see Node#cloneNode
+     * @see Node#duplicateNode
+     * @see NodeComponent#setDuplicateOnCloneTree
+     */
+     @Override
+     public Node cloneNode(boolean forceDuplicate) {
+	 Group g = new Group();
+	 g.duplicateNode(this, forceDuplicate);
+	 return g;
+    }
+
+
+    /**
+     * Constructs a Group node with default parameters.  The default
+     * values are as follows:
+     * <ul>
+     * collision bounds : null<br>
+     * alternate collision target : false<br>
+     * </ul>
+     */
+    public Group() {
+        // set default read capabilities
+        setDefaultReadCapabilities(readCapabilities);
+    }
+}