1 files changed, 248 insertions, 0 deletions
diff --git a/src/javax/media/j3d/NodeComponentRetained.java b/src/javax/media/j3d/NodeComponentRetained.java
new file mode 100644
index 0000000..c424257
--- /dev/null
+++ b/src/javax/media/j3d/NodeComponentRetained.java
@@ -0,0 +1,248 @@
+/*
+ * Copyright 1997-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.ArrayList;
+
+/**
+ * Retained version of NodeComponent
+ */
+
+class NodeComponentRetained extends SceneGraphObjectRetained {
+
+    // duplicate or make a reference when cloneTree() is called
+    //  on this object.
+    boolean duplicateOnCloneTree = false;
+
+    // This keeps track of how many times this NodeComponent is referenced in
+    // the Scene Graph
+    int refCount = 0;		// this is used in setLive
+    int refCnt = 0;		// this is used in compile
+
+    // This is true when this appearance is referenced in an immediate mode context
+    private boolean inImmCtx = false;
+
+    // A list of NodeRetained Objects that refer, directly or indirectly, to this
+    // NodeComponentRetained
+    ArrayList users = new ArrayList(1);
+
+    // Mirror object of this node compoenent object
+    NodeComponentRetained mirror = null;
+
+    // Sole User FrequencyBit
+    // In the case of Appearance, its a bitmask of all components
+    int changedFrequent = 0;
+    int compChanged = 0;
+
+    // Increment the refcount.  If this is the first, mark it as live.
+    void doSetLive(boolean inBackgroundGroup, int refCount) {
+	int oldRefCount = this.refCount;
+	this.refCount += refCount;
+	if (oldRefCount <= 0) {
+	    super.doSetLive(inBackgroundGroup);
+
+	    // Create and init a mirror object if not already there
+	    // The two procedures is combined since it is redunctant to
+	    // call initMirrorObject() if mirror == this (static object).
+	    createMirrorObject();
+	}
+    }
+
+    void setLive(boolean inBackgroundGroup, int refCount) {
+	int oldRefCount = this.refCount;
+	doSetLive(inBackgroundGroup, refCount);
+	if (oldRefCount <= 0) {
+	    super.markAsLive();
+	}
+    }
+
+
+
+    // Decrement the refcount.  If this is the last, mark it as not live.
+    void clearLive(int refCount) {
+	this.refCount -= refCount;
+
+	if (this.refCount <= 0) {
+	    super.clearLive();
+	}
+    }
+
+    // increment the compile reference count
+    synchronized void incRefCnt() {
+	refCnt++;
+    }
+
+    // decrement the compile reference count
+    synchronized void decRefCnt() {
+	refCnt--;
+    }
+
+    // remove mirror shape from the list of users
+    void removeAMirrorUser(Shape3DRetained ms) {
+	synchronized(mirror.users) {
+	    mirror.users.remove(ms);
+	}
+    }
+
+    // Add a mirror shape to the list of users
+    void addAMirrorUser(Shape3DRetained ms) {
+	synchronized(mirror.users) {
+	    mirror.users.add(ms);
+	}
+    }
+
+    // Copy the list of useres passed in into this
+    void copyMirrorUsers(NodeComponentRetained node) {
+	synchronized(mirror.users) {
+	  synchronized(node.mirror.users) {
+	      int size = node.mirror.users.size();
+	      for (int i=0; i<size ; i++) {
+		  mirror.users.add(node.mirror.users.get(i));
+	      }
+	    }
+	}
+    }
+
+
+    // Remove the users of "node" from "this" node compoenent
+    void removeMirrorUsers(NodeComponentRetained node) {
+
+	synchronized(mirror.users) {
+	  synchronized(node.mirror.users) {
+	      for (int i=node.mirror.users.size()-1; i>=0; i--) {
+		  mirror.users.remove(mirror.users.indexOf(node.mirror.users.get(i)));
+	      }
+	    }
+	}
+    }
+
+    // Add a user to the list of users
+    synchronized void removeUser(NodeRetained node) {
+	if (node.source.isLive())
+	    users.remove(users.indexOf(node));
+    }
+
+    // Add a user to the list of users
+    synchronized void addUser(NodeRetained node) {
+	if (node.source.isLive())
+	    users.add(node);
+    }
+
+
+    // Add a user to the list of users
+    synchronized void notifyUsers() {
+
+	if (source == null || !source.isLive()) {
+	    return;
+	}
+
+	for (int i=users.size()-1; i >=0; i--) {
+	    ((NodeRetained)users.get(i)).notifySceneGraphChanged(false);
+	}
+    }
+
+    /**
+     * This sets the immedate mode context flag
+     */
+    void setInImmCtx(boolean inCtx) {
+        inImmCtx = inCtx;
+    }
+
+    /**
+     * This gets the immedate mode context flag
+     */
+    boolean getInImmCtx() {
+        return (inImmCtx);
+    }
+
+    /**
+     * Sets this node's duplicateOnCloneTree value.  The
+     * <i>duplicateOnCloneTree</i> value is used to determine if NodeComponent
+     * objects are to be duplicated or referenced during a
+     * <code>cloneTree</code> operation. A value of <code>true</code> means
+     *  that this NodeComponent object should be duplicated, while a value
+     *  of <code>false</code> indicates that this NodeComponent object's
+     *  reference will be copied into the newly cloned object.  This value
+     *  can be overriden via the <code>forceDuplicate</code> parameter of
+     *  the <code>cloneTree</code> method.
+     * @param duplicate the value to set.
+     * @see Node#cloneTree
+     */
+    void setDuplicateOnCloneTree(boolean duplicate) {
+	duplicateOnCloneTree = duplicate;
+    }
+
+    /**
+     * Returns this node's duplicateOnCloneTree value. The
+     * <i>duplicateOnCloneTree</i> value is used to determine if NodeComponent
+     * objects are to be duplicated or referenced during a
+     * <code>cloneTree</code> operation. A value of <code>true</code> means
+     *  that this NodeComponent object should be duplicated, while a value
+     *  of <code>false</code> indicates that this NodeComponent object's
+     *  reference will be copied into the newly cloned object.  This value
+     *  can be overriden via the <code>forceDuplicate</code> parameter of
+     *  the <code>cloneTree</code> method.
+     * @return the value of this node's duplicateOnCloneTree
+     * @see Node#cloneTree
+     */
+    boolean getDuplicateOnCloneTree() {
+	return duplicateOnCloneTree;
+    }
+
+
+    void initMirrorObject() {
+    }
+
+    void updateMirrorObject(int component, Object obj) {
+    }
+
+    void createMirrorObject() {
+	// Overridden by appearance and other classes
+	initMirrorObject();
+	mirror = null;
+    }
+
+    void setFrequencyChangeMask(int bit, int mask) {
+	if (source.getCapabilityIsFrequent(bit))
+	    changedFrequent |= mask;
+	else if (!source.isLive()) {
+            // Record the freq->infreq change only for non-live node components
+	    changedFrequent &= ~mask;
+	}
+    }
+
+     @Override
+     protected Object clone() {
+         NodeComponentRetained ncr = (NodeComponentRetained)super.clone();
+	 ncr.changedFrequent = changedFrequent;
+	 return ncr;
+     }
+
+    protected void set(NodeComponentRetained nc) {
+	changedFrequent = nc.changedFrequent;
+    }
+}