void onClose(SwRenderArea renderArea) {
  SoNode root = renderArea.getSceneGraph();
  renderArea.setSceneGraph(null);
  if (root.isDisposable())
  root.dispose();
}

Using the isDisposable() method

All Open Inventor classes that have the dispose mechanism implement the interface com.openinventor.inventor.SafeDisposable. The method isDisposable() returns true if the Open Inventor object can be disposed safely; in fact it will be true only if the object is no longer referenced by Open Inventor. A generic example of disposing an Open Inventor object might be:

void safeDisposeInventorObject(SafeDisposable oivObj) {
  // remove all ref to oivObj
  ...
  if (oivObj.isDisposable())
    oivObj.dispose();
}

If the application tries to dispose an object without testing isDisposable() and the object is still referenced by Open Inventor, then the exception java.lang.IllegalStateException will be thrown. Therefore, an alternate way to dispose might be:

void safeDisposeInventorObject(SafeDisposable oivObj) {
  // remove all ref to oivObj
  ...
  try {
    oivObj.dispose();
  } catch (java.lang.IllegalStateException exc) {
  }
}

Recursive dispose

If dispose() is applied to a group node instance (SoGroup or any derived class), the method traverses all the group’s children recursively. Thus, the whole scene graph rooted at this group is disposed. It is not necessary for an application to traverse explicitly all the children, remove the children, and dispose them. The following pictures explain what append when sroot.dispose() is called.

When the scene graph shares some internal nodes with another scene graph, the dispose() method will only dispose the nodes that are not shared. The following pictures explain what append when sroot1.dispose() is called.

Limitation 1:

This implicit recursive behavior does not apply for any Inventor node that refers to some other nodes by a field SoSFNode or SoMFNode. Example:

SoVertexProperty myVertexProperty = new SoVertexProperty();
SoIndexedFaceSet myShape = new SoIndexedFaceSet();
myShape.vertexProperty.setValue(myVertexProperty);

if (myShape.isDisposable())
  myShape.dispose();

In this example, even if myShape is disposable, Open Inventor does not ensure that the node myVertexProperty is disposed; that will happen when the JVM can collect the myVertexProperty instance. The following code could be used as workaround:

void disposeIndexedShape(SoIndexedFaceSet myShape)
{
  SoVertexProperty vertexProperty = (SoVertexProperty)myShape.vertexProperty.getValue();
  if (myShape.isDisposable())
    myShape.dispose();
  if (vertexProperty.isDisposable())
    vertexProperty.dispose();
}

The same limitation exists for field containers such as SoSFFieldContainer and SoMFFieldContainer, and also for any SoVolumeReader set by an SoVolumeData. The volume data keeps an instance of this reader, but when disposing the volume data, its volume reader may not be disposed until the runtime collects it. For example:

SoVolumeData volumeData = new SoVolumeData();
SoVRMemoryReader volumeReader = new SoVRMemoryReader();
volumeData.setReader(volumeReader);
if (volumeData.isDisposable())
  volumeData.dispose();

In this example, after volumeData is disposed, volumeReader may be not disposed.

Limitation 2:

SoPath also has the same kind of limitation. If the application adds some Inventor nodes to an SoPath, those nodes may not be disposed when this path is disposed, even if they are not referenced elsewhere. For example:

SoGroup group1 = new SoGroup();
SoGroup group2 = new SoGroup();
SoPath path = new SoPath();
path.regular.append(group1);
path.regular.append(group2);
if (path.isDisposable())
  path.dispose();

In this example, after path is disposed, group1 and group2 may be not disposed.

When an SoSearchAction is successfully applied, the getPath() method returns an SoPath instance containing an ordered list of nodes from the searched scene graph. As the action keeps a reference to the returned path, the path and also the nodes in the path cannot be disposed before the action. Unfortunately, the SoAction classes do not implement the dispose() method. Therefore, the path and its nodes cannot be disposed before the runtime collects the action instance.

SoGroup root = new SoGroup();
SoCone cone = new SoCone();
root.addChild(cone);

SoSearchAction searchAction = new SoSearchAction();
searchAction.setNodeClass(SoCone.class);
searchAction.apply(root);
SoPath path = searchAction.getPath();

if (root.isDisposable())
  root.dispose();

In this example, the root is not disposable because the path maintains a reference to root. Furthermore the path is also not disposable because the action maintains a reference to the path. The action must be collected before the path and root can be disposed.

In order to dispose the root before the action is collected, the action must remove its references to any path. It can be done by calling reset() like in the following example:

SoGroup root = new SoGroup();
SoCone cone = new SoCone();
root.addChild(cone);

SoSearchAction searchAction = new SoSearchAction();
searchAction.setNodeClass(SoCone.class);
searchAction.apply(root);
SoPath path = searchAction.getPath();

// remove the reference to the path 
searchAction.reset();

// dispose the path in order to let the root be disposable
if (path.isDisposable())
  path.dispose();

if (root.isDisposable())
  root.dispose();

The same constraint exists when using an SoRayPickAction. When a picking occurs the action handles a list of SoPickedPoint. As each SoPickedPoint handles also an SoPath, the method clearPickedPointList() must be called before trying to dispose the root:

SoGroup root = new SoGroup();
SoCone cone = new SoCone();
root.addChild(cone);

SoRayPickAction pickAction = new SoRayPickAction(new SbViewportRegion());
pickAction.setRay(new SbVec3f(0, 0, 0), new SbVec3f(0.5f, 0.5f, 0.5f));
pickAction.apply(root);
SoPickedPoint pickedPoint = pickAction.getPickedPoint();
SoPath pickedPath = pickedPoint.getPath();

// removes the reference to the picked point list
pickAction.clearPickedPointList();

// dispose the path in order to let the root be disposable
if (pickedPath.isDisposable())
  pickedPath.dispose();

if (root.isDisposable())
  root.dispose();