forked from bartvdbraak/blender
835 lines
27 KiB
Python
835 lines
27 KiB
Python
# 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 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": [],
|
|
}
|
|
|
|
|
|
|