path: root/intern/python/modules/vrml/scenegraph.py

# VRML node prototype class (SGbuilder)
# Wed Oct 31 16:18:35 CET 2001

'''Prototype2 -- VRML 97 sceneGraph/Node/Script/ROUTE/IS implementations'''
import copy, types # extern
import strop as string # builtin
from utils import typeclasses, err, namespace # XXX
## TODO: namespace must go


class baseProto:
	def __vrmlStr__( self, **namedargs ):
		'''Generate a VRML 97-syntax string representing this Prototype
		**namedargs -- key:value
			passed arguments for the linearisation object
		see lineariser4.Lineariser
		'''
		import lineariser4 
		lineariser = apply( lineariser4.Lineariser, (), namedargs )
		return apply( lineariser.linear, ( self, ), namedargs )

	toString = __vrmlStr__ 
	# added stuff for linking support for target scenegraph
	def setTargetnode(self, node):
		self.__dict__['_targetnode'] = node
	def getTargetnode(self):
		try:
			return self.__dict__['_targetnode']
		except:
			return None

class Prototype(baseProto):
	''' A VRML 97 Prototype object
	
	A Prototype is a callable object which produces Node instances
	the Node uses a pointer to its Prototype to provide much of the
	Node's standard functionality.

	Prototype's are often stored in a sceneGraph's protoTypes namespace,
	where you can access them as sceneGraph.protoTypes.nodeGI . They are
	also commonly found in Nodes' PROTO attributes.
	
	Attributes:
		__gi__ -- constant string "PROTO"
		nodeGI -- string gi
			The "generic identifier" of the node type, i.e. the name of the node
		fieldDictionary -- string name: (string name, string dataType, boolean exposed)
		defaultDictionary -- string name: object defaultValue
			Will be blank for EXTERNPROTO's and Script prototypes
		eventDictionary -- string name: (string name, string dataType, boolean eventOut)
		sceneGraph -- object sceneGraph
		MFNodeNames -- list of field name strings
			Allows for easy calculation of "children" nodes
		SFNodeNames -- list of field name strings
			Allows for easy calculation of "children" nodes
	'''
	__gi__ = "PROTO"
	def __init__(self, gi, fieldDict=None, defaultDict=None, eventDict=None, sGraph=None):
		'''
		gi -- string gi
			see attribute nodeGI
		fieldDict -- string name: (string name, string dataType, boolean exposed)
			see attribute fieldDictionary
		defaultDict -- string name: object defaultValue
			see attribute defaultDictionary
		eventDict -- string name: (string name, string dataType, boolean eventOut)
			see attribute eventDictionary
		sceneGraph -- object sceneGraph
			see attribute sceneGraph
		'''
		self.nodeGI = checkName( gi )
		self.fieldDictionary = {}
		self.defaultDictionary = {}
		self.eventDictionary = {}
		self.SFNodeNames = []
		self.MFNodeNames = []
		self.sceneGraph = sGraph

		# setup the fields/events
		for definition in (fieldDict or {}).values():
			self.addField( definition, (defaultDict or {}).get( definition[0]))
		for definition in (eventDict or {}).values():
			self.addEvent( definition )
			
	def getSceneGraph( self ):
		''' Retrieve the sceneGraph object (may be None object)
		see attribute sceneGraph'''
		return self.sceneGraph
	def setSceneGraph( self, sceneGraph ):
		''' Set the sceneGraph object (may be None object)
		see attribute sceneGraph'''
		self.sceneGraph = sceneGraph
	def getChildren(self, includeSceneGraph=None, includeDefaults=1, *args, **namedargs):
		''' Calculate the current children of the PROTO and return as a list of nodes
		if includeDefaults:
			include those default values which are node values
		if includeSceneGraph:
			include the sceneGraph object if it is not None

		see attribute MFNodeNames
		see attribute SFNodeNames
		see attribute sceneGraph
		'''
		temp = []
		if includeDefaults:
			for attrname in self.SFNodeNames:
				try:
					temp.append( self.defaultDictionary[attrname] )
				except KeyError: # sceneGraph object is not copied...
					pass
			for attrname in self.MFNodeNames:
				try:
					temp[len(temp):] = self.defaultDictionary[attrname]
				except KeyError:
					pass
		if includeSceneGraph and self.sceneGraph:
			temp.append( self.getSceneGraph() )
		return temp
	def addField (self, definition, default = None):
		''' Add a single field definition to the Prototype
		definition -- (string name, string dataType, boolean exposed)
		default -- object defaultValue
		
		see attribute fieldDictionary
		see attribute defaultDictionary
		'''
		if type (definition) == types.InstanceType:
			definition = definition.getDefinition()
			default = definition.getDefault ()
		self.removeField( definition[0] )
		self.fieldDictionary[definition [0]] = definition
		if default is not None:
			default = fieldcoercian.FieldCoercian()( default, definition[1] )
			self.defaultDictionary [definition [0]] = default
		if definition[1] == 'SFNode':
			self.SFNodeNames.append(definition[0])
		elif definition[1] == 'MFNode':
			self.MFNodeNames.append(definition[0])
	def removeField (self, key):
		''' Remove a single field from the Prototype
		key -- string fieldName
			The name of the field to remove
		'''
		if self.fieldDictionary.has_key (key):
			del self.fieldDictionary [key]
		if self.defaultDictionary.has_key (key):
			del self.defaultDictionary [key]
		for attribute in (self.SFNodeNames, self.MFNodeNames):
			while key in attribute:
				attribute.remove(key)
	def addEvent(self, definition):
		''' Add a single event definition to the Prototype
		definition -- (string name, string dataType, boolean eventOut)
		
		see attribute eventDictionary
		'''
		if type (definition) == types.InstanceType:
			definition = definition.getDefinition()
		self.eventDictionary[definition [0]] = definition
	def removeEvent(self, key):
		''' Remove a single event from the Prototype
		key -- string eventName
			The name of the event to remove
		'''
		if self.eventDictionary.has_key (key):
			del self.eventDictionary [key]
	def getField( self, key ):
		'''Return a Field or Event object representing a given name
		key -- string name
			The name of the field or event to retrieve
			will attempt to match key, key[4:], and key [:-8]
			corresponding to key, set_key and key_changed

		see class Field
		see class Event
		'''
#		print self.fieldDictionary, self.eventDictionary
		for tempkey in (key, key[4:], key[:-8]):
			if self.fieldDictionary.has_key( tempkey ):
				return Field( self.fieldDictionary[tempkey], self.defaultDictionary.get(tempkey) )
			elif self.eventDictionary.has_key( tempkey ):
				return Event( self.eventDictionary[tempkey] )
		raise AttributeError, key
	def getDefault( self, key ):
		'''Return the default value for the given field
		key -- string name
			The name of the field
			Will attempt to match key, key[4:], and key [:-8]
			corresponding to key, set_key and key_changed

		see attribute defaultDictionary
		'''
		for key in (key, key[4:], key[:-8]):
			if self.defaultDictionary.has_key( key ):
				val = self.defaultDictionary[key]
				if type(val) in typeclasses.MutableTypes:
					val = copy.deepcopy( val )
				return val
			elif self.fieldDictionary.has_key( key ):
				'''We have the field, but we don't have a default, we are likely an EXTERNPROTO'''
				return None
		raise AttributeError, key
	def setDefault (self, key, value):
		'''Set the default value for the given field
		key -- string name
			The name of the field to set
		value -- object defaultValue
			The default value, will be checked for type and coerced if necessary
		'''
		field = self.getField (key)
		self.defaultDictionary [field.name]= field.coerce (value)
	def clone( self, children = 1, sceneGraph = 1 ):
		'''Return a copy of this Prototype
		children -- boolean
			if true, copy the children of the Prototype, otherwise include them
		sceneGraph -- boolean
			if true, copy the sceneGraph of the Prototype
		'''
		if sceneGraph:
			sceneGraph = self.sceneGraph
		else:
			sceneGraph = None
		# defaults should always be copied before modification, but this is still dangerous...
		defaultDictionary = self.defaultDictionary.copy()
		if not children:
			for attrname in self.SFNodeNames+self.MFNodeNames:
				try:
					del defaultDictionary[attrname]
				except KeyError: # sceneGraph object is not copied...
					pass
		# now make a copy
		if self.__gi__ == "PROTO":
			newNode = self.__class__(
				self.nodeGI,
				self.fieldDictionary,
				defaultDictionary,
				self.eventDictionary,
				sceneGraph,
			)
		else:
			newNode = self.__class__(
				self.nodeGI,
				self.url,
				self.fieldDictionary,
				self.eventDictionary,
			)
		return newNode
	def __call__(self, *args, **namedargs):
		'''Create a new Node instance associated with this Prototype
		*args, **namedargs -- passed to the Node.__init__
		see class Node
		'''
		node = apply( Node, (self, )+args, namedargs )
		return node
	def __repr__ ( self ):
		'''Create a simple Python representation'''
		return '''%s( %s )'''%( self.__class__.__name__, self.nodeGI )

class ExternalPrototype( Prototype ):
	'''Sub-class of Prototype

	The ExternalPrototype is a minor sub-classing of the Prototype
	it does not have any defaults, nor a sceneGraph
	
	Attributes:
		__gi__ -- constant string "EXTERNPROTO"
		url -- string list urls
			implementation source for the ExternalPrototype
	'''
	__gi__ = "EXTERNPROTO"
	def __init__(self, gi, url=None, fieldDict=None, eventDict=None):
		'''
		gi -- string gi
			see attribute nodeGI
		url -- string list url
			MFString-compatible list of url's for EXTERNPROTO
		fieldDict -- string name: (string name, string dataType, boolean exposed)
			see attribute fieldDictionary
		eventDict -- string name: (string name, string dataType, boolean eventOut)
			see attribute eventDictionary
		'''
		if url is None:
			url = []
		self.url = url
		Prototype.__init__( self, gi, fieldDict=fieldDict, eventDict=eventDict)
	

from vrml import fieldcoercian # XXX
class Field:
	''' Representation of a Prototype Field
	The Field object is a simple wrapper to provide convenient
	access to field coercian and meta- information
	'''
	def __init__( self, specification, default=None ):
		self.name, self.type, self.exposure = specification
		self.default = default
	def getDefinition (self):
		return self.name, self.type, self.exposure
	def getDefault (self):
		return self.default
	def coerce( self, value ):
		''' Coerce value to the appropriate dataType for this Field '''
		return fieldcoercian.FieldCoercian()( value,self.type,  )
	def __repr__( self ):
		if hasattr (self, "default"):
			return '%s( (%s,%s,%s), %s)'%( self.__class__.__name__, self.name, self.type, self.exposure, self.default)
		else:
			return '%s( (%s,%s,%s),)'%( self.__class__.__name__, self.name, self.type, self.exposure)
	def __str__( self ):
		if self.exposure:
			exposed = "exposedField"
		else:
			exposed = field
		if hasattr (self, "default"):
			default = ' ' + str( self.default)
		else:
			default = ""
		return '%s %s %s%s'%(exposed, self.type, self.name, default)

class Event (Field):
	def __str__( self ):
		if self.exposure:
			exposed = "eventOut"
		else:
			exposed = "eventIn"
		return '%s %s %s'%(exposed, self.type, self.name)


### Translation strings for VRML node names...
translationstring = '''][0123456789{}"'#,.\\ \000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023'''
NAMEFIRSTCHARTRANSLATOR = string.maketrans( translationstring, '_'*len(translationstring) )
translationstring = '''][{}"'#,.\\ \000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023'''
NAMERESTCHARTRANSLATOR = string.maketrans( translationstring, '_'*len(translationstring) )
del translationstring
def checkName( name ):
	'''Convert arbitrary string to a valid VRML id'''
	if type(name) is types.StringType:
		if not name:
			return name
		return string.translate( name[:1], NAMEFIRSTCHARTRANSLATOR) + string.translate( name[1:], NAMERESTCHARTRANSLATOR)
	else:
		raise TypeError, "VRML Node Name must be a string, was a %s: %s"%(type(name), name)

class Node(baseProto):
	''' A VRML 97 Node object
	
	A Node object represents a VRML 97 node.  Attributes of the Node
	can be set/retrieved with standard python setattr/getattr syntax.
	VRML 97 attributes may be passed to the constructor as named
	arguments.
	
	Attributes:
		__gi__ -- string PROTOname
		DEF -- string DEFName
			The DEF name of the node, will be coerced to be a valid
			identifier (with "" being considered valid)
		PROTO -- Prototype PROTO
			The node's Prototype object
		attributeDictionary -- string name: object value
			Dictionary in which VRML 97 attributes are stored
	'''
	DEF = '' # the default name for all nodes (arbitrary)
	def __init__(self, PROTO, name='', attrDict=None, *args, **namedargs):
		'''Normally this method is only called indirectly via the Prototype() interface
		PROTO -- Prototype PROTO
			see attribute PROTO
		name -- string DEFName
			see attribute DEF
		attrDict -- string name: object value
			see attribute attributeDictionary
		**namedargs -- string name: object value
			added to attrDict to create attributeDictionary
		'''
		self.__dict__["PROTO"] = PROTO
		self.DEF = name
		self.__dict__["attributeDictionary"] = {}
##		print attrDict, namedargs
		for dict in (attrDict or {}), namedargs:
			if dict:
				for key, value in dict.items ():
					self.__setattr__( key, value, check=1 )

	def __setattr__( self, key, value, check=1, raw=0 ):
		'''Set attribute on Node
		key -- string attributeName
		value -- object attributeValue
		check -- boolean check
			if false, put values for unrecognized keys into __dict__
			otherwise, raise an  AttributeError
		'''
		if key == "DEF":
			self.__dict__["DEF"] = checkName( value )
			return None
		elif key == "PROTO":
			self.__dict__["PROTO"] = value
		try:
			field = self.PROTO.getField( key )
			if (hasattr( value, "__gi__") and value.__gi__ == "IS") or raw:
				self.attributeDictionary[ field.name] = value
			else:
				self.attributeDictionary[ field.name] = field.coerce( value )
		except ValueError, x:
			raise ValueError( "Could not coerce value %s into value of VRML type %s for %s node %s's field %s"%( value, field.type, self.__gi__, self.DEF, key), x.args)
		except (AttributeError), x:
			if check:
				raise AttributeError("%s is not a known field for node %s"%(key, repr(self)))
			else:
				self.__dict__[key] = value
	def __getattr__( self, key, default = 1 ):
		''' Retrieve an attribute when standard lookup fails
		key -- string attributeName
		default -- boolean default
			if true, return the default value if the node does not have local value
			otherwise, raise AttributeError
		'''
		if key != "attributeDictionary":
			if self.__dict__.has_key( key):
				return self.__dict__[ key ]
			elif self.attributeDictionary.has_key( key):
				return self.attributeDictionary[key]
			if key != "PROTO":
				if key == "__gi__":
					return self.PROTO.nodeGI
				elif default:
					try:
						default = self.PROTO.getDefault( key )
						if type( default ) in typeclasses.MutableTypes:
							# we need a copy, not the original
							default = copy.deepcopy( default )
							self.__setattr__( key, default, check=0, raw=1 )
						return default
					except AttributeError:
						pass
		raise AttributeError, key
	def __delattr__( self, key ):
		''' Delete an attribute from the Node
		key -- string attributeName
		'''
		if key != "attributeDictionary":
			if self.attributeDictionary.has_key( key):
				del self.attributeDictionary[key]
			elif self.__dict__.has_key( key):
				del self.__dict__[ key ]
		raise AttributeError, key
			
	def __repr__(self):
		''' Create simple python representation '''
		return '<%s(%s): %s>'%(self.__gi__, `self.DEF`, self.attributeDictionary.keys() )
	def getChildrenNames( self, current = 1, *args, **namedargs ):
		''' Get the (current) children of Node
		returns two lists:  MFNode children, SFNode children
		current -- boolean currentOnly
			if true, only return current children
			otherwise, include all potential children
		'''
		MFNODES, SFNODES = self.PROTO.MFNodeNames, self.PROTO.SFNodeNames
		mns, sns = [],[]
		for key in MFNODES:
			if current and self.attributeDictionary.has_key(key):
				mns.append(key)
			elif not current:
				mns.append(key)
		for key in SFNODES:
			if self.attributeDictionary.has_key(key):
				sns.append(key)
			elif not current:
				sns.append(key)
		return mns,sns
	def calculateChildren(self, *args, **namedargs):
		'''Calculate the current children of the Node as list of Nodes
		'''
		MFNODES, SFNODES = self.getChildrenNames( )
		temp = []
		for key in MFNODES:
			try:
				temp.extend( self.__getattr__( key, default=0 ) )
			except AttributeError:
				pass
		for key in SFNODES:
			try:
				temp.append( self.__getattr__(key, default = 0 ) )
			except AttributeError:
				pass
		return temp
	def clone(self, newclass=None, name=None, children=None, attrDeepCopy=1, *args, **namedargs):
		'''Return a copy of this Node
		newclass -- object newClass  or None
			optionally use a different Prototype as base
		name -- string DEFName or None or 1
			if 1, copy from current
			elif None, set to ""
			else, set to passed value
		children -- boolean copyChildren
			if true, copy the children of this node
			otherwise, skip children
		attrDeepCopy -- boolean deepCopy
			if true, use deepcopy
			otherwise, use copy
		'''
		if attrDeepCopy:
			cpy = copy.deepcopy
		else:
			cpy = copy.copy
		newattrs = self.attributeDictionary.copy()
		if not children:
			mnames,snames = self.getChildrenNames( )
			for key in mnames+snames:
				try:
					del(newattrs[key])
				except KeyError:
					pass
		for key, val in newattrs.items():
			if type(val) in typeclasses.MutableTypes:
				newattrs[key] = cpy(val)
		# following is Node specific, won't work for sceneGraphs, scripts, etceteras
		if name == 1: # asked to copy the name
			name = self.DEF
		elif name is None: # asked to clear the name
			name = ''
		if not newclass:
			newclass = self.PROTO
		return newclass( name, newattrs )
	def __cmp__( self, other, stop=None ):
		''' Compare this node to another object/node
		other -- object otherNode
		stop -- boolean stopIfFailure
			if true, failure to find comparison causes match failure (i.e. considered unequal)
		'''
			
		if hasattr( other, '__gi__') and other.__gi__ == self.__gi__:
			try:
				return cmp( self.DEF, other.DEF) or cmp( self.attributeDictionary, other.attributeDictionary )
			except:
				if not stop:
					try:
						return other.__cmp__( self , 1) # 1 being stop...
					except:
						pass
		return -1 # could be one, doesn't really matter

def Script( name="", attrDict=None, fieldDict=None, defaultDict=None, eventDict=None, **namedarguments):
	''' Create a script node (and associated prototype)
	name -- string DEFName
	attrDict -- string name: object value
		see class Node.attributeDictionary
	fieldDict -- string name: (string name, string dataType,  boolean exposure)
		see class Prototype.fieldDictionary
	defaultDict -- string name: object value
		see class Prototype.defaultDictionary
	eventDict -- string name: (string name, string dataType, boolean eventOut)
	'''
	fieldDictionary = {
		'directOutput':('directOutput', 'SFBool',0),
		'url':('url',"MFString",0),
		'mustEvaluate':('mustEvaluate', 'SFBool',0),
	}
	fieldDictionary.update( fieldDict or {})
	defaultDictionary = {
		"directOutput":0,
		"url":[],
		"mustEvaluate":0,
	}
	defaultDictionary.update( defaultDict or {})
	PROTO = Prototype(
		"Script",
		fieldDictionary,
		defaultDictionary ,
		eventDict = eventDict,
	)
	if attrDict is not None:
		attrDict.update( namedarguments )
	else:
		attrDict = namedarguments
	return PROTO( name, attrDict )


class NullNode:
	'''NULL SFNode value
	There should only be a single NULL instance for
	any particular system.  It should, for all intents and
	purposes just sit there inertly
	'''
	__gi__ = 'NULL'
	DEF = ''
	__walker_is_temporary_item__ = 1 # hacky signal to walking engine not to reject this node as already processed
	def __repr__(self):
		return '<NULL vrml SFNode>'
	def __vrmlStr__(self,*args,**namedargs):
		return ' NULL '
	toString = __vrmlStr__
	def __nonzero__(self ):
		return 0
	def __call__(self, *args, **namedargs):
		return self
	def __cmp__( self, other ):
		if hasattr( other, '__gi__') and other.__gi__ == self.__gi__:
			return 0
		return -1 # could be one, doesn't really matter
	def clone( self ):
		return self
NULL = NullNode()
	
class fieldRef:
	'''IS Prototype field reference
	'''
	__gi__ = 'IS'
	DEF = ''
	def __init__(self, declaredName):
		self.declaredName = declaredName
	def __repr__(self):
		return 'IS %s'%self.declaredName
	def __vrmlStr__(self,*args,**namedargs):
		return 'IS %s'%self.declaredName
	toString = __vrmlStr__
	def __cmp__( self, other ):
		if hasattr( other, '__gi__') and other.__gi__ == self.__gi__:
			return cmp( self.declaredName, other.declaredName )
		return -1 # could be one, doesn't really matter
	def clone( self ):
		return self.__class__( self.declaredName )
		
IS = fieldRef

class ROUTE:
	''' VRML 97 ROUTE object
	The ROUTE object keeps track of its source and destination nodes and attributes
	It generally lives in a sceneGraph's "routes" collection
	'''
	__gi__ = 'ROUTE'
	def __init__( self, fromNode, fromField, toNode, toField ):
		if type(fromNode) is types.StringType:
			raise TypeError( "String value for ROUTE fromNode",fromNode)
		if type(toNode) is types.StringType:
			raise TypeError( "String value for ROUTE toNode",toNode)
		self.fromNode = fromNode
		self.fromField = fromField
		self.toNode = toNode
		self.toField = toField
	def __getitem__( self, index ):
		return (self.fromNode, self.fromField, self.toNode, self.toField)[index]
	def __setitem__( self, index, value ):
		attribute = ("fromNode","fromField","toNode", "toField")[index]
		setattr( self, attribute, value )
	def __repr__( self ):
		return 'ROUTE %s.%s TO %s.%s'%( self.fromNode.DEF, self.fromField, self.toNode.DEF, self.toField )
	def clone( self ):
		return self.__class__( 
			self.fromNode,
			self.fromField,
			self.toNode,
			self.toField,
		)


class sceneGraph(baseProto):
	''' A VRML 97 sceneGraph
	Attributes:
		__gi__ -- constant string "sceneGraph"
		DEF -- constant string ""
		children -- Node list
			List of the root children of the sceneGraph, nodes/scripts only
		routes -- ROUTE list
			List of the routes within the sceneGraph
		defNames -- string DEFName: Node node
			Mapping of DEF names to their respective nodes
		protoTypes -- Namespace prototypes
			Namespace (with chaining lookup) collection of prototypes
			getattr( sceneGraph.protoTypes, 'nodeGI' ) retrieves a prototype
	'''
	__gi__ = 'sceneGraph'
	DEF = ''
	def __init__(self, root=None, protoTypes=None, routes=None, defNames=None, children=None, *args, **namedargs):
		'''
		root -- sceneGraph root or Dictionary root or Module root or None
			Base object for root of protoType namespace hierarchy
		protoTypes -- string nodeGI: Prototype PROTO
			Dictionary of prototype definitions
		routes -- ROUTE list or (string sourcenode, string sourceeventOut, string destinationnode, string destinationeventOut) list
			List of route objects or tuples to be added to the sceneGraph
			see attribute routes
		defNames -- string DEFName: Node node
			see attribute defNames
		children -- Node list
			see attribute children
		'''
		if children is None:
			self.children = []
		else:
			self.children = children
		if routes is None:
			self.routes = [] # how will we efficiently handle routes?
		else:
			self.routes = routes
		if defNames == None:
			self.defNames = {} # maps 'defName':Node
		else:
			self.defNames = defNames
		if protoTypes is None:
			protoTypes = {}
		if root is None:
			from vrml import basenodes # XXX
			self.protoTypes = namespace.NameSpace(
				protoTypes,
				children = [namespace.NameSpace(basenodes)]
			)
		else: # there is a root file, so need to use it as the children instead of basenodes...
			if hasattr( root, "protoTypes"):
				self.protoTypes = namespace.NameSpace(
					protoTypes,
					children = [root.protoTypes]
				)
			else:
				self.protoTypes = namespace.NameSpace(
					protoTypes,
					children = [ namespace.NameSpace(root) ]
				)
	def __getinitargs__( self ):
		# we only copy our explicit protos, our routes, our defNames, and our children
		# inherited protos will be pulled along by their nodes...
		return None, self.protoTypes._base, self.routes, self.defNames, self.children
	def __getstate__( self ):
		return {}
	def __setstate__( self, dict ):
		pass
	def __del__( self, id=id ):
		'''
		Need to clean up the namespace's mutual references,
		this can be done without affecting the cascade by just
		eliminating the key/value pairs.  The namespaces will
		no longer contain the prototypes, but they will still
		chain up to the higher-level namespaces, and the nodes
		will have those prototypes still in use.
		'''
##		print 'del sceneGraph', id(self )
		try:
##			import pdb
##			pdb.set_trace()
##			self.protoTypes.__dict__.clear()
			self.protoTypes._base.clear()
			del self.protoTypes.__namespace_cascade__[:]
		except:
			print 'unable to free references'
		
	def addRoute(self, routeTuple, getNewNodes=0):
		''' Add a single route to the sceneGraph
		routeTuple -- ROUTE route or (string sourcenode, string sourceeventOut, string destinationnode, string destinationeventOut)
		getNewNodes -- boolean getNewNodes
			if true, look up sourcenode and destinationnode within the current defNames to determine source/destination nodes
			otherwise, just use current if available
		'''
		# create and wire together the Routes here,
		# should just be a matter of pulling the events and passing the nodes...
##		import pdb
##		pdb.set_trace()
		if type( routeTuple) in ( types.TupleType, types.ListType):
			(fromNode, fromField, toNode, toField ) = routeTuple
			if type(fromNode) is types.StringType:
				# get the node instead of the string...
				if self.defNames.has_key( fromNode ):
					fromNode = self.defNames[fromNode]
				else:
					err.err( "ROUTE from an unknown node %s "%(routeTuple) )
					return 0
			if type(toNode) is types.StringType:
				# get the node instead of the string...
				if self.defNames.has_key( toNode ):
					toNode = self.defNames[toNode]
				else:
					err.err( "ROUTE to an unknown node %s "%(routeTuple) )
					return 0
			routeTuple = ROUTE( fromNode, fromField, toNode, toField)
		elif getNewNodes:
			# get the nodes with the same names...
			if self.defNames.has_key( routeTuple[0].DEF ):
				routeTuple[0] = self.defNames[routeTuple[0].DEF]
			else:
				err.err( "ROUTE from an unknown node %s "%(routeTuple) )
				return 0
			if self.defNames.has_key( routeTuple[2].DEF ):
				routeTuple[2] = self.defNames[routeTuple[2].DEF]
			else:
				err.err( "ROUTE to an unknown node %s "%(routeTuple) )
				return 0
		# should be a Route node now, append to our ROUTE list...
		self.routes.append(routeTuple)
		return 1
	def regDefName(self, defName, object):
		''' Register a DEF name for a particular object
		defName -- string DEFName
		object -- Node node
		'''
		object.DEF = defName
		self.defNames[defName] = object
	def addProto(self, proto):
		'''Register a Prototype for this sceneGraph
		proto -- Prototype PROTO
		'''
		setattr( self.protoTypes, proto.__gi__, proto )
	#toString = __vrmlStr__ 
	#__vrmlStr__ = toString
##	def __setattr__( self, key, value ):
##		if key == 'protoTypes' and type( value) is types.ListType:
##			import pdb
##			pdb.set_trace()
##			raise TypeError( "Invalid type for protoTypes attribute of sceneGraph %s"%(`value`) )
##		else:
##			self.__dict__[key] = value

DEFAULTFIELDVALUES ={
	"SFBool": 0,
	"SFString": "",
	"SFFloat": 0,
	"SFTime": 0,
	"SFVec3f": (0, 0,0),
	"SFVec2f": (0,0),
	"SFRotation": (0, 1,0, 0),
	"SFInt32": 0,
	"SFImage": (0,0,0),
	"SFColor": (0,0, 0),
	"SFNode": NULL,
	"MFString": [],
	"MFFloat": [],
	"MFTime": [],
	"MFVec3f": [],
	"MFVec2f": [],
	"MFRotation": [],
	"MFInt32": [],
	"MFColor": [],
	"MFNode": [],
}