import six
import json
import sys
class X3DNode(object):
    def __init__(self, **kwargs):
        super(X3DNode, self).__init__()
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DNode'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DNode>'
        return str


class X3DAppearanceChildNode(X3DNode):
    def __init__(self, **kwargs):
        super(X3DAppearanceChildNode, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DAppearanceChildNode'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DAppearanceChildNode>'
        return str


class X3DAppearanceNode(X3DNode):
    def __init__(self, **kwargs):
        super(X3DAppearanceNode, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DAppearanceNode'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DAppearanceNode>'
        return str


class X3DChildNode(X3DNode):
    def __init__(self, **kwargs):
        super(X3DChildNode, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DChildNode'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DChildNode>'
        return str


class X3DBindableNode(X3DChildNode):
    def __init__(self, **kwargs):
        super(X3DBindableNode, self).__init__(**kwargs)
        bindTime  = kwargs.pop("bindTime", None)
        self.__bindTime = bindTime
        Bound  = kwargs.pop("Bound", None)
        self.__Bound = Bound
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        bind  = kwargs.pop("bind", None)
        self.__bind = bind
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def removeBindTime(self, bindTime):
        self.__bindTime = [x for x in self.__bindTime if x not in bindTime]
        return self.__bindTime
    def getBindTime(self, bindTime = None):
        return self.__bindTime
    def bindTime_changed(self, bindTime = None):
        return self.__bindTime
    def isBound(self, Bound = None):
        return self.__Bound
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def bind(self):
        return self.__bind
    @bind.setter
    def bind(self, value = None):
        self.__bind = [value]
    def set_bind(self, bind = None):
        self.__bind = [bind]
        return self
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DBindableNode'
        if self.__bindTime is not None:
            if isinstance(self.__bindTime, six.string_types):
                str += ' bindTime="'+self.__bindTime+'"'
            else:
                str += ' bindTime="'+self.__bindTime[0]+'"'
        if self.__Bound is not None:
            if isinstance(self.__Bound, six.string_types):
                str += ' Bound="'+self.__Bound+'"'
            else:
                str += ' Bound="'+self.__Bound[0]+'"'
        if self.__bind is not None:
            if isinstance(self.__bind, six.string_types):
                str += ' bind="'+self.__bind+'"'
            else:
                str += ' bind="'+self.__bind[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DBindableNode>'
        return str


class X3DBackgroundNode(X3DBindableNode):
    def __init__(self, **kwargs):
        super(X3DBackgroundNode, self).__init__(**kwargs)
        bindTime  = kwargs.pop("bindTime", None)
        self.__bindTime = bindTime
        groundAngle  = kwargs.pop("groundAngle", None)
        if groundAngle == None or len(groundAngle) <= 0 or min(groundAngle)  <  0:
            return None
        if groundAngle == None or len(groundAngle) <= 0 or max(groundAngle)  >  1.5708:
            return None
        self.__groundAngle = groundAngle
        groundColor  = kwargs.pop("groundColor", None)
        if groundColor == None or len(groundColor) <= 0 or min(groundColor)  <  0:
            return None
        if groundColor == None or len(groundColor) <= 0 or max(groundColor)  >  1:
            return None
        self.__groundColor = groundColor
        Bound  = kwargs.pop("Bound", None)
        self.__Bound = Bound
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        bind  = kwargs.pop("bind", None)
        self.__bind = bind
        skyAngle  = kwargs.pop("skyAngle", None)
        if skyAngle == None or len(skyAngle) <= 0 or min(skyAngle)  <  0:
            return None
        if skyAngle == None or len(skyAngle) <= 0 or max(skyAngle)  >  3.1416:
            return None
        self.__skyAngle = skyAngle
        skyColor  = kwargs.pop("skyColor", [0, 0, 0])
        if skyColor == None or len(skyColor) <= 0 or min(skyColor)  <  0:
            return None
        if skyColor == None or len(skyColor) <= 0 or max(skyColor)  >  1:
            return None
        self.__skyColor = skyColor
        transparency  = kwargs.pop("transparency", 0)
        if transparency == None or transparency  <  0:
            return None
        if transparency == None or transparency  >  1:
            return None
        self.__transparency = transparency
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def removeBindTime(self, bindTime):
        self.__bindTime = [x for x in self.__bindTime if x not in bindTime]
        return self.__bindTime
    def getBindTime(self, bindTime = None):
        return self.__bindTime
    def bindTime_changed(self, bindTime = None):
        return self.__bindTime
    @property
    def groundAngle(self):
        return self.__groundAngle
    @groundAngle.setter
    def groundAngle(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1.5708:
            return None
        self.__groundAngle = [value]
    def setGroundAngle(self, groundAngle = None):
        if groundAngle == None or len(groundAngle) <= 0 or min(groundAngle)  <  0:
            return None
        if groundAngle == None or len(groundAngle) <= 0 or max(groundAngle)  >  1.5708:
            return None
        self.__groundAngle = [groundAngle]
        return self
    def addGroundAngle(self, groundAngle = None):
        if groundAngle == None or len(groundAngle) <= 0 or min(groundAngle)  <  0:
            return None
        if groundAngle == None or len(groundAngle) <= 0 or max(groundAngle)  >  1.5708:
            return None
        if self.__groundAngle == None:            self.__groundAngle =  []
        self.__groundAngle +=  [groundAngle]
        return self
    def removeGroundAngle(self, groundAngle):
        self.__groundAngle = [x for x in self.__groundAngle if x not in groundAngle]
        return self.__groundAngle
    def getGroundAngle(self, groundAngle = None):
        return self.__groundAngle
    def groundAngle_changed(self, groundAngle = None):
        return self.__groundAngle
    @property
    def groundColor(self):
        return self.__groundColor
    @groundColor.setter
    def groundColor(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__groundColor = [value]
    def setGroundColor(self, groundColor = None):
        if groundColor == None or len(groundColor) <= 0 or min(groundColor)  <  0:
            return None
        if groundColor == None or len(groundColor) <= 0 or max(groundColor)  >  1:
            return None
        self.__groundColor = [groundColor]
        return self
    def addGroundColor(self, groundColor = None):
        if groundColor == None or len(groundColor) <= 0 or min(groundColor)  <  0:
            return None
        if groundColor == None or len(groundColor) <= 0 or max(groundColor)  >  1:
            return None
        if self.__groundColor == None:            self.__groundColor =  []
        self.__groundColor +=  [groundColor]
        return self
    def removeGroundColor(self, groundColor):
        self.__groundColor = [x for x in self.__groundColor if x not in groundColor]
        return self.__groundColor
    def getGroundColor(self, groundColor = None):
        return self.__groundColor
    def groundColor_changed(self, groundColor = None):
        return self.__groundColor
    def isBound(self, Bound = None):
        return self.__Bound
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def bind(self):
        return self.__bind
    @bind.setter
    def bind(self, value = None):
        self.__bind = [value]
    def set_bind(self, bind = None):
        self.__bind = [bind]
        return self
    @property
    def skyAngle(self):
        return self.__skyAngle
    @skyAngle.setter
    def skyAngle(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  3.1416:
            return None
        self.__skyAngle = [value]
    def setSkyAngle(self, skyAngle = None):
        if skyAngle == None or len(skyAngle) <= 0 or min(skyAngle)  <  0:
            return None
        if skyAngle == None or len(skyAngle) <= 0 or max(skyAngle)  >  3.1416:
            return None
        self.__skyAngle = [skyAngle]
        return self
    def addSkyAngle(self, skyAngle = None):
        if skyAngle == None or len(skyAngle) <= 0 or min(skyAngle)  <  0:
            return None
        if skyAngle == None or len(skyAngle) <= 0 or max(skyAngle)  >  3.1416:
            return None
        if self.__skyAngle == None:            self.__skyAngle =  []
        self.__skyAngle +=  [skyAngle]
        return self
    def removeSkyAngle(self, skyAngle):
        self.__skyAngle = [x for x in self.__skyAngle if x not in skyAngle]
        return self.__skyAngle
    def getSkyAngle(self, skyAngle = None):
        return self.__skyAngle
    def skyAngle_changed(self, skyAngle = None):
        return self.__skyAngle
    @property
    def skyColor(self):
        return self.__skyColor
    @skyColor.setter
    def skyColor(self, value = [0, 0, 0]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__skyColor = [value]
    def setSkyColor(self, skyColor = [0, 0, 0]):
        if skyColor == None or len(skyColor) <= 0 or min(skyColor)  <  0:
            return None
        if skyColor == None or len(skyColor) <= 0 or max(skyColor)  >  1:
            return None
        self.__skyColor = [skyColor]
        return self
    def addSkyColor(self, skyColor = [0, 0, 0]):
        if skyColor == None or len(skyColor) <= 0 or min(skyColor)  <  0:
            return None
        if skyColor == None or len(skyColor) <= 0 or max(skyColor)  >  1:
            return None
        if self.__skyColor == None:            self.__skyColor =  []
        self.__skyColor +=  [skyColor]
        return self
    def removeSkyColor(self, skyColor):
        self.__skyColor = [x for x in self.__skyColor if x not in skyColor]
        return self.__skyColor
    def getSkyColor(self, skyColor = [0, 0, 0]):
        return self.__skyColor
    def skyColor_changed(self, skyColor = [0, 0, 0]):
        return self.__skyColor
    @property
    def transparency(self):
        return self.__transparency
    @transparency.setter
    def transparency(self, value = 0):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__transparency = [value]
    def setTransparency(self, transparency = 0):
        if transparency == None or transparency  <  0:
            return None
        if transparency == None or transparency  >  1:
            return None
        self.__transparency = [transparency]
        return self
    def addTransparency(self, transparency = 0):
        if transparency == None or transparency  <  0:
            return None
        if transparency == None or transparency  >  1:
            return None
        if self.__transparency == None:            self.__transparency =  []
        self.__transparency +=  [transparency]
        return self
    def removeTransparency(self, transparency):
        self.__transparency = [x for x in self.__transparency if x not in transparency]
        return self.__transparency
    def getTransparency(self, transparency = 0):
        return self.__transparency
    def transparency_changed(self, transparency = 0):
        return self.__transparency
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DBackgroundNode'
        if self.__bindTime is not None:
            if isinstance(self.__bindTime, six.string_types):
                str += ' bindTime="'+self.__bindTime+'"'
            else:
                str += ' bindTime="'+self.__bindTime[0]+'"'
        if self.__groundAngle is not None:
            if isinstance(self.__groundAngle, six.string_types):
                str += ' groundAngle="'+self.__groundAngle+'"'
            else:
                str += ' groundAngle="'+self.__groundAngle[0]+'"'
        if self.__groundColor is not None:
            if isinstance(self.__groundColor, six.string_types):
                str += ' groundColor="'+self.__groundColor+'"'
            else:
                str += ' groundColor="'+self.__groundColor[0]+'"'
        if self.__Bound is not None:
            if isinstance(self.__Bound, six.string_types):
                str += ' Bound="'+self.__Bound+'"'
            else:
                str += ' Bound="'+self.__Bound[0]+'"'
        if self.__bind is not None:
            if isinstance(self.__bind, six.string_types):
                str += ' bind="'+self.__bind+'"'
            else:
                str += ' bind="'+self.__bind[0]+'"'
        if self.__skyAngle is not None:
            if isinstance(self.__skyAngle, six.string_types):
                str += ' skyAngle="'+self.__skyAngle+'"'
            else:
                str += ' skyAngle="'+self.__skyAngle[0]+'"'
        if self.__skyColor is not None:
            if isinstance(self.__skyColor, six.string_types):
                str += ' skyColor="'+self.__skyColor+'"'
            else:
                str += ' skyColor="'+self.__skyColor[0]+'"'
        if self.__transparency is not None:
            if isinstance(self.__transparency, six.string_types):
                str += ' transparency="'+self.__transparency+'"'
            else:
                str += ' transparency="'+self.__transparency[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DBackgroundNode>'
        return str


class X3DFollowerNode(X3DChildNode):
    def __init__(self, **kwargs):
        super(X3DFollowerNode, self).__init__(**kwargs)
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def isActive(self, Active = None):
        return self.__Active
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DFollowerNode'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DFollowerNode>'
        return str


class X3DChaserNode(X3DFollowerNode):
    def __init__(self, **kwargs):
        super(X3DChaserNode, self).__init__(**kwargs)
        duration  = kwargs.pop("duration", 1)
        if duration == None or duration  <  0:
            return None
        self.__duration = duration
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def isActive(self, Active = None):
        return self.__Active
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DChaserNode'
        if self.__duration is not None:
            if isinstance(self.__duration, six.string_types):
                str += ' duration="'+self.__duration+'"'
            else:
                str += ' duration="'+self.__duration[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DChaserNode>'
        return str


class X3DGeometricPropertyNode(X3DNode):
    def __init__(self, **kwargs):
        super(X3DGeometricPropertyNode, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DGeometricPropertyNode'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DGeometricPropertyNode>'
        return str


class X3DColorNode(X3DGeometricPropertyNode):
    def __init__(self, **kwargs):
        super(X3DColorNode, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DColorNode'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DColorNode>'
        return str


class X3DVolumeRenderStyleNode(X3DNode):
    def __init__(self, **kwargs):
        super(X3DVolumeRenderStyleNode, self).__init__(**kwargs)
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DVolumeRenderStyleNode'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DVolumeRenderStyleNode>'
        return str


class X3DComposableVolumeRenderStyleNode(X3DVolumeRenderStyleNode):
    def __init__(self, **kwargs):
        super(X3DComposableVolumeRenderStyleNode, self).__init__(**kwargs)
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DComposableVolumeRenderStyleNode'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DComposableVolumeRenderStyleNode>'
        return str


class X3DGeometryNode(X3DNode):
    def __init__(self, **kwargs):
        super(X3DGeometryNode, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DGeometryNode'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DGeometryNode>'
        return str


class X3DComposedGeometryNode(X3DGeometryNode):
    def __init__(self, **kwargs):
        super(X3DComposedGeometryNode, self).__init__(**kwargs)
        attrib  = kwargs.pop("attrib", None)
        self.__attrib = attrib
        ccw  = kwargs.pop("ccw", True)
        self.__ccw = ccw
        color  = kwargs.pop("color", None)
        self.__color = color
        colorPerVertex  = kwargs.pop("colorPerVertex", True)
        self.__colorPerVertex = colorPerVertex
        coord  = kwargs.pop("coord", None)
        self.__coord = coord
        fogCoord  = kwargs.pop("fogCoord", None)
        self.__fogCoord = fogCoord
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        normal  = kwargs.pop("normal", None)
        self.__normal = normal
        normalPerVertex  = kwargs.pop("normalPerVertex", True)
        self.__normalPerVertex = normalPerVertex
        solid  = kwargs.pop("solid", True)
        self.__solid = solid
        texCoord  = kwargs.pop("texCoord", None)
        self.__texCoord = texCoord
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def attrib(self):
        return self.__attrib
    @attrib.setter
    def attrib(self, value = None):
        self.__attrib = [value]
    def setAttrib(self, attrib = None):
        self.__attrib = [attrib]
        return self
    def addAttrib(self, attrib = None):
        if self.__attrib == None:            self.__attrib =  []
        self.__attrib +=  [attrib]
        return self
    def removeAttrib(self, attrib):
        self.__attrib = [x for x in self.__attrib if x not in attrib]
        return self.__attrib
    def getAttrib(self, attrib = None):
        return self.__attrib
    def attrib_changed(self, attrib = None):
        return self.__attrib
    @property
    def color(self):
        return self.__color
    @color.setter
    def color(self, value = None):
        self.__color = [value]
    def setColor(self, color = None):
        self.__color = [color]
        return self
    def addColor(self, color = None):
        if self.__color == None:            self.__color =  []
        self.__color +=  [color]
        return self
    def removeColor(self, color):
        self.__color = [x for x in self.__color if x not in color]
        return self.__color
    def getColor(self, color = None):
        return self.__color
    def color_changed(self, color = None):
        return self.__color
    @property
    def coord(self):
        return self.__coord
    @coord.setter
    def coord(self, value = None):
        self.__coord = [value]
    def setCoord(self, coord = None):
        self.__coord = [coord]
        return self
    def addCoord(self, coord = None):
        if self.__coord == None:            self.__coord =  []
        self.__coord +=  [coord]
        return self
    def removeCoord(self, coord):
        self.__coord = [x for x in self.__coord if x not in coord]
        return self.__coord
    def getCoord(self, coord = None):
        return self.__coord
    def coord_changed(self, coord = None):
        return self.__coord
    @property
    def fogCoord(self):
        return self.__fogCoord
    @fogCoord.setter
    def fogCoord(self, value = None):
        self.__fogCoord = [value]
    def setFogCoord(self, fogCoord = None):
        self.__fogCoord = [fogCoord]
        return self
    def addFogCoord(self, fogCoord = None):
        if self.__fogCoord == None:            self.__fogCoord =  []
        self.__fogCoord +=  [fogCoord]
        return self
    def removeFogCoord(self, fogCoord):
        self.__fogCoord = [x for x in self.__fogCoord if x not in fogCoord]
        return self.__fogCoord
    def getFogCoord(self, fogCoord = None):
        return self.__fogCoord
    def fogCoord_changed(self, fogCoord = None):
        return self.__fogCoord
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def normal(self):
        return self.__normal
    @normal.setter
    def normal(self, value = None):
        self.__normal = [value]
    def setNormal(self, normal = None):
        self.__normal = [normal]
        return self
    def addNormal(self, normal = None):
        if self.__normal == None:            self.__normal =  []
        self.__normal +=  [normal]
        return self
    def removeNormal(self, normal):
        self.__normal = [x for x in self.__normal if x not in normal]
        return self.__normal
    def getNormal(self, normal = None):
        return self.__normal
    def normal_changed(self, normal = None):
        return self.__normal
    @property
    def texCoord(self):
        return self.__texCoord
    @texCoord.setter
    def texCoord(self, value = None):
        self.__texCoord = [value]
    def setTexCoord(self, texCoord = None):
        self.__texCoord = [texCoord]
        return self
    def addTexCoord(self, texCoord = None):
        if self.__texCoord == None:            self.__texCoord =  []
        self.__texCoord +=  [texCoord]
        return self
    def removeTexCoord(self, texCoord):
        self.__texCoord = [x for x in self.__texCoord if x not in texCoord]
        return self.__texCoord
    def getTexCoord(self, texCoord = None):
        return self.__texCoord
    def texCoord_changed(self, texCoord = None):
        return self.__texCoord
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DComposedGeometryNode'
        if self.__ccw is not None:
            if isinstance(self.__ccw, six.string_types):
                str += ' ccw="'+self.__ccw+'"'
            else:
                str += ' ccw="'+self.__ccw[0]+'"'
        if self.__colorPerVertex is not None:
            if isinstance(self.__colorPerVertex, six.string_types):
                str += ' colorPerVertex="'+self.__colorPerVertex+'"'
            else:
                str += ' colorPerVertex="'+self.__colorPerVertex[0]+'"'
        if self.__normalPerVertex is not None:
            if isinstance(self.__normalPerVertex, six.string_types):
                str += ' normalPerVertex="'+self.__normalPerVertex+'"'
            else:
                str += ' normalPerVertex="'+self.__normalPerVertex[0]+'"'
        if self.__solid is not None:
            if isinstance(self.__solid, six.string_types):
                str += ' solid="'+self.__solid+'"'
            else:
                str += ' solid="'+self.__solid[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<attrib'
        if self.__attrib is not None:
           for s in self.__attrib:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__attrib is not None:
           for s in self.__attrib:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</attrib>'
        str += '<color'
        if self.__color is not None:
           for s in self.__color:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__color is not None:
           for s in self.__color:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</color>'
        str += '<coord'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</coord>'
        str += '<fogCoord'
        if self.__fogCoord is not None:
           for s in self.__fogCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__fogCoord is not None:
           for s in self.__fogCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</fogCoord>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<normal'
        if self.__normal is not None:
           for s in self.__normal:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__normal is not None:
           for s in self.__normal:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</normal>'
        str += '<texCoord'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</texCoord>'
        str += '</X3DComposedGeometryNode>'
        return str


class X3DCoordinateNode(X3DGeometricPropertyNode):
    def __init__(self, **kwargs):
        super(X3DCoordinateNode, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DCoordinateNode'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DCoordinateNode>'
        return str


class X3DDamperNode(X3DFollowerNode):
    def __init__(self, **kwargs):
        super(X3DDamperNode, self).__init__(**kwargs)
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        order  = kwargs.pop("order", 3)
        if order == None or order  <  0:
            return None
        if order == None or order  >  5:
            return None
        self.__order = order
        tau  = kwargs.pop("tau", 0.3)
        if tau == None or tau  <  0:
            return None
        self.__tau = tau
        tolerance  = kwargs.pop("tolerance", -1)
        self.__tolerance = tolerance
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def isActive(self, Active = None):
        return self.__Active
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def tau(self):
        return self.__tau
    @tau.setter
    def tau(self, value = 0.3):
        if value == None or value  <  0:
            return None
        self.__tau = [value]
    def setTau(self, tau = 0.3):
        if tau == None or tau  <  0:
            return None
        self.__tau = [tau]
        return self
    def addTau(self, tau = 0.3):
        if tau == None or tau  <  0:
            return None
        if self.__tau == None:            self.__tau =  []
        self.__tau +=  [tau]
        return self
    def removeTau(self, tau):
        self.__tau = [x for x in self.__tau if x not in tau]
        return self.__tau
    def getTau(self, tau = 0.3):
        return self.__tau
    def tau_changed(self, tau = 0.3):
        return self.__tau
    @property
    def tolerance(self):
        return self.__tolerance
    @tolerance.setter
    def tolerance(self, value = -1):
        self.__tolerance = [value]
    def setTolerance(self, tolerance = -1):
        self.__tolerance = [tolerance]
        return self
    def addTolerance(self, tolerance = -1):
        if self.__tolerance == None:            self.__tolerance =  []
        self.__tolerance +=  [tolerance]
        return self
    def removeTolerance(self, tolerance):
        self.__tolerance = [x for x in self.__tolerance if x not in tolerance]
        return self.__tolerance
    def getTolerance(self, tolerance = -1):
        return self.__tolerance
    def tolerance_changed(self, tolerance = -1):
        return self.__tolerance
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DDamperNode'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__order is not None:
            if isinstance(self.__order, six.string_types):
                str += ' order="'+self.__order+'"'
            else:
                str += ' order="'+self.__order[0]+'"'
        if self.__tau is not None:
            if isinstance(self.__tau, six.string_types):
                str += ' tau="'+self.__tau+'"'
            else:
                str += ' tau="'+self.__tau[0]+'"'
        if self.__tolerance is not None:
            if isinstance(self.__tolerance, six.string_types):
                str += ' tolerance="'+self.__tolerance+'"'
            else:
                str += ' tolerance="'+self.__tolerance[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DDamperNode>'
        return str


class X3DSensorNode(X3DChildNode):
    def __init__(self, **kwargs):
        super(X3DSensorNode, self).__init__(**kwargs)
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    def isActive(self, Active = None):
        return self.__Active
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DSensorNode'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DSensorNode>'
        return str


class X3DPointingDeviceSensorNode(X3DSensorNode):
    def __init__(self, **kwargs):
        super(X3DPointingDeviceSensorNode, self).__init__(**kwargs)
        description  = kwargs.pop("description", None)
        self.__description = description
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        Over  = kwargs.pop("Over", None)
        self.__Over = Over
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def description(self):
        return self.__description
    @description.setter
    def description(self, value = None):
        self.__description = [value]
    def setDescription(self, description = None):
        self.__description = [description]
        return self
    def addDescription(self, description = None):
        if self.__description == None:            self.__description =  []
        self.__description +=  [description]
        return self
    def removeDescription(self, description):
        self.__description = [x for x in self.__description if x not in description]
        return self.__description
    def getDescription(self, description = None):
        return self.__description
    def description_changed(self, description = None):
        return self.__description
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    def isActive(self, Active = None):
        return self.__Active
    def isOver(self, Over = None):
        return self.__Over
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DPointingDeviceSensorNode'
        if self.__description is not None:
            if isinstance(self.__description, six.string_types):
                str += ' description="'+self.__description+'"'
            else:
                str += ' description="'+self.__description[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__Over is not None:
            if isinstance(self.__Over, six.string_types):
                str += ' Over="'+self.__Over+'"'
            else:
                str += ' Over="'+self.__Over[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DPointingDeviceSensorNode>'
        return str


class X3DDragSensorNode(X3DPointingDeviceSensorNode):
    def __init__(self, **kwargs):
        super(X3DDragSensorNode, self).__init__(**kwargs)
        autoOffset  = kwargs.pop("autoOffset", True)
        self.__autoOffset = autoOffset
        description  = kwargs.pop("description", None)
        self.__description = description
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        Over  = kwargs.pop("Over", None)
        self.__Over = Over
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        trackPoint_changed  = kwargs.pop("trackPoint_changed", None)
        self.__trackPoint_changed = trackPoint_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def autoOffset(self):
        return self.__autoOffset
    @autoOffset.setter
    def autoOffset(self, value = True):
        self.__autoOffset = [value]
    def setAutoOffset(self, autoOffset = True):
        self.__autoOffset = [autoOffset]
        return self
    def addAutoOffset(self, autoOffset = True):
        if self.__autoOffset == None:            self.__autoOffset =  []
        self.__autoOffset +=  [autoOffset]
        return self
    def removeAutoOffset(self, autoOffset):
        self.__autoOffset = [x for x in self.__autoOffset if x not in autoOffset]
        return self.__autoOffset
    def isAutoOffset(self, autoOffset = True):
        return self.__autoOffset
    @property
    def description(self):
        return self.__description
    @description.setter
    def description(self, value = None):
        self.__description = [value]
    def setDescription(self, description = None):
        self.__description = [description]
        return self
    def addDescription(self, description = None):
        if self.__description == None:            self.__description =  []
        self.__description +=  [description]
        return self
    def removeDescription(self, description):
        self.__description = [x for x in self.__description if x not in description]
        return self.__description
    def getDescription(self, description = None):
        return self.__description
    def description_changed(self, description = None):
        return self.__description
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    def isActive(self, Active = None):
        return self.__Active
    def isOver(self, Over = None):
        return self.__Over
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    def removetrackPoint_changed(self, trackPoint_changed):
        self.__trackPoint_changed = [x for x in self.__trackPoint_changed if x not in trackPoint_changed]
        return self.__trackPoint_changed
    def gettrackPoint_changed(self, trackPoint_changed = None):
        return self.__trackPoint_changed
    def trackPoint_changed_changed(self, trackPoint_changed = None):
        return self.__trackPoint_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DDragSensorNode'
        if self.__autoOffset is not None:
            if isinstance(self.__autoOffset, six.string_types):
                str += ' autoOffset="'+self.__autoOffset+'"'
            else:
                str += ' autoOffset="'+self.__autoOffset[0]+'"'
        if self.__description is not None:
            if isinstance(self.__description, six.string_types):
                str += ' description="'+self.__description+'"'
            else:
                str += ' description="'+self.__description[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__Over is not None:
            if isinstance(self.__Over, six.string_types):
                str += ' Over="'+self.__Over+'"'
            else:
                str += ' Over="'+self.__Over[0]+'"'
        if self.__trackPoint_changed is not None:
            if isinstance(self.__trackPoint_changed, six.string_types):
                str += ' trackPoint_changed="'+self.__trackPoint_changed+'"'
            else:
                str += ' trackPoint_changed="'+self.__trackPoint_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DDragSensorNode>'
        return str


class X3DEnvironmentalSensorNode(X3DSensorNode):
    def __init__(self, **kwargs):
        super(X3DEnvironmentalSensorNode, self).__init__(**kwargs)
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        size  = kwargs.pop("size", [0, 0, 0])
        if size == None or len(size) <= 0 or min(size)  <  0:
            return None
        self.__size = size
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    def isActive(self, Active = None):
        return self.__Active
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DEnvironmentalSensorNode'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__size is not None:
            if isinstance(self.__size, six.string_types):
                str += ' size="'+self.__size+'"'
            else:
                str += ' size="'+self.__size[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DEnvironmentalSensorNode>'
        return str


class X3DTextureNode(X3DAppearanceChildNode):
    def __init__(self, **kwargs):
        super(X3DTextureNode, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DTextureNode'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DTextureNode>'
        return str


class X3DEnvironmentTextureNode(X3DTextureNode):
    def __init__(self, **kwargs):
        super(X3DEnvironmentTextureNode, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DEnvironmentTextureNode'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DEnvironmentTextureNode>'
        return str


class X3DFontStyleNode(X3DNode):
    def __init__(self, **kwargs):
        super(X3DFontStyleNode, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DFontStyleNode'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DFontStyleNode>'
        return str


class X3DBoundedObject(object):
    def __init__(self, **kwargs):
        super(X3DBoundedObject, self).__init__()
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DBoundedObject'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        str += '>'
        str += '</X3DBoundedObject>'
        return str


class X3DGroupingNode(X3DBoundedObject, X3DChildNode):
    def __init__(self, **kwargs):
        super(X3DGroupingNode, self).__init__(**kwargs)
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        children  = kwargs.pop("children", None)
        self.__children = children
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    def addChildren(self, Children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [Children]
        return self
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DGroupingNode'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '</X3DGroupingNode>'
        return str


class X3DInfoNode(X3DChildNode):
    def __init__(self, **kwargs):
        super(X3DInfoNode, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DInfoNode'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DInfoNode>'
        return str


class X3DInterpolatorNode(X3DChildNode):
    def __init__(self, **kwargs):
        super(X3DInterpolatorNode, self).__init__(**kwargs)
        key  = kwargs.pop("key", None)
        self.__key = key
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        fraction  = kwargs.pop("fraction", None)
        self.__fraction = fraction
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def key(self):
        return self.__key
    @key.setter
    def key(self, value = None):
        self.__key = [value]
    def setKey(self, key = None):
        self.__key = [key]
        return self
    def addKey(self, key = None):
        if self.__key == None:            self.__key =  []
        self.__key +=  [key]
        return self
    def removeKey(self, key):
        self.__key = [x for x in self.__key if x not in key]
        return self.__key
    def getKey(self, key = None):
        return self.__key
    def key_changed(self, key = None):
        return self.__key
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def fraction(self):
        return self.__fraction
    @fraction.setter
    def fraction(self, value = None):
        self.__fraction = [value]
    def set_fraction(self, fraction = None):
        self.__fraction = [fraction]
        return self
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DInterpolatorNode'
        if self.__key is not None:
            if isinstance(self.__key, six.string_types):
                str += ' key="'+self.__key+'"'
            else:
                str += ' key="'+self.__key[0]+'"'
        if self.__fraction is not None:
            if isinstance(self.__fraction, six.string_types):
                str += ' fraction="'+self.__fraction+'"'
            else:
                str += ' fraction="'+self.__fraction[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DInterpolatorNode>'
        return str


class X3DKeyDeviceSensorNode(X3DSensorNode):
    def __init__(self, **kwargs):
        super(X3DKeyDeviceSensorNode, self).__init__(**kwargs)
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    def isActive(self, Active = None):
        return self.__Active
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DKeyDeviceSensorNode'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DKeyDeviceSensorNode>'
        return str


class X3DLayerNode(X3DNode):
    def __init__(self, **kwargs):
        super(X3DLayerNode, self).__init__(**kwargs)
        Pickable  = kwargs.pop("Pickable", True)
        self.__Pickable = Pickable
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        viewport  = kwargs.pop("viewport", None)
        self.__viewport = viewport
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def Pickable(self):
        return self.__Pickable
    @Pickable.setter
    def Pickable(self, value = True):
        self.__Pickable = [value]
    def setIsPickable(self, Pickable = True):
        self.__Pickable = [Pickable]
        return self
    def addIsPickable(self, Pickable = True):
        if self.__Pickable == None:            self.__Pickable =  []
        self.__Pickable +=  [Pickable]
        return self
    def isPickable(self, Pickable = True):
        return self.__Pickable
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def viewport(self):
        return self.__viewport
    @viewport.setter
    def viewport(self, value = None):
        self.__viewport = [value]
    def setViewport(self, viewport = None):
        self.__viewport = [viewport]
        return self
    def addViewport(self, viewport = None):
        if self.__viewport == None:            self.__viewport =  []
        self.__viewport +=  [viewport]
        return self
    def removeViewport(self, viewport):
        self.__viewport = [x for x in self.__viewport if x not in viewport]
        return self.__viewport
    def getViewport(self, viewport = None):
        return self.__viewport
    def viewport_changed(self, viewport = None):
        return self.__viewport
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DLayerNode'
        if self.__Pickable is not None:
            if isinstance(self.__Pickable, six.string_types):
                str += ' Pickable="'+self.__Pickable+'"'
            else:
                str += ' Pickable="'+self.__Pickable[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<viewport'
        if self.__viewport is not None:
           for s in self.__viewport:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__viewport is not None:
           for s in self.__viewport:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</viewport>'
        str += '</X3DLayerNode>'
        return str


class X3DLayoutNode(X3DChildNode):
    def __init__(self, **kwargs):
        super(X3DLayoutNode, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DLayoutNode'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DLayoutNode>'
        return str


class X3DLightNode(X3DChildNode):
    def __init__(self, **kwargs):
        super(X3DLightNode, self).__init__(**kwargs)
        ambientIntensity  = kwargs.pop("ambientIntensity", 0)
        if ambientIntensity == None or ambientIntensity  <  0:
            return None
        if ambientIntensity == None or ambientIntensity  >  1:
            return None
        self.__ambientIntensity = ambientIntensity
        color  = kwargs.pop("color", [1, 1, 1])
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        self.__color = color
        intensity  = kwargs.pop("intensity", 1)
        if intensity == None or intensity  <  0:
            return None
        if intensity == None or intensity  >  1:
            return None
        self.__intensity = intensity
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        on  = kwargs.pop("on", True)
        self.__on = on
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def ambientIntensity(self):
        return self.__ambientIntensity
    @ambientIntensity.setter
    def ambientIntensity(self, value = 0):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__ambientIntensity = [value]
    def setAmbientIntensity(self, ambientIntensity = 0):
        if ambientIntensity == None or ambientIntensity  <  0:
            return None
        if ambientIntensity == None or ambientIntensity  >  1:
            return None
        self.__ambientIntensity = [ambientIntensity]
        return self
    def addAmbientIntensity(self, ambientIntensity = 0):
        if ambientIntensity == None or ambientIntensity  <  0:
            return None
        if ambientIntensity == None or ambientIntensity  >  1:
            return None
        if self.__ambientIntensity == None:            self.__ambientIntensity =  []
        self.__ambientIntensity +=  [ambientIntensity]
        return self
    def removeAmbientIntensity(self, ambientIntensity):
        self.__ambientIntensity = [x for x in self.__ambientIntensity if x not in ambientIntensity]
        return self.__ambientIntensity
    def getAmbientIntensity(self, ambientIntensity = 0):
        return self.__ambientIntensity
    def ambientIntensity_changed(self, ambientIntensity = 0):
        return self.__ambientIntensity
    @property
    def color(self):
        return self.__color
    @color.setter
    def color(self, value = [1, 1, 1]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__color = [value]
    def setColor(self, color = [1, 1, 1]):
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        self.__color = [color]
        return self
    def addColor(self, color = [1, 1, 1]):
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        if self.__color == None:            self.__color =  []
        self.__color +=  [color]
        return self
    def removeColor(self, color):
        self.__color = [x for x in self.__color if x not in color]
        return self.__color
    def getColor(self, color = [1, 1, 1]):
        return self.__color
    def color_changed(self, color = [1, 1, 1]):
        return self.__color
    @property
    def intensity(self):
        return self.__intensity
    @intensity.setter
    def intensity(self, value = 1):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__intensity = [value]
    def setIntensity(self, intensity = 1):
        if intensity == None or intensity  <  0:
            return None
        if intensity == None or intensity  >  1:
            return None
        self.__intensity = [intensity]
        return self
    def addIntensity(self, intensity = 1):
        if intensity == None or intensity  <  0:
            return None
        if intensity == None or intensity  >  1:
            return None
        if self.__intensity == None:            self.__intensity =  []
        self.__intensity +=  [intensity]
        return self
    def removeIntensity(self, intensity):
        self.__intensity = [x for x in self.__intensity if x not in intensity]
        return self.__intensity
    def getIntensity(self, intensity = 1):
        return self.__intensity
    def intensity_changed(self, intensity = 1):
        return self.__intensity
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def on(self):
        return self.__on
    @on.setter
    def on(self, value = True):
        self.__on = [value]
    def setOn(self, on = True):
        self.__on = [on]
        return self
    def addOn(self, on = True):
        if self.__on == None:            self.__on =  []
        self.__on +=  [on]
        return self
    def removeOn(self, on):
        self.__on = [x for x in self.__on if x not in on]
        return self.__on
    def isOn(self, on = True):
        return self.__on
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DLightNode'
        if self.__ambientIntensity is not None:
            if isinstance(self.__ambientIntensity, six.string_types):
                str += ' ambientIntensity="'+self.__ambientIntensity+'"'
            else:
                str += ' ambientIntensity="'+self.__ambientIntensity[0]+'"'
        if self.__color is not None:
            if isinstance(self.__color, six.string_types):
                str += ' color="'+self.__color+'"'
            else:
                str += ' color="'+self.__color[0]+'"'
        if self.__intensity is not None:
            if isinstance(self.__intensity, six.string_types):
                str += ' intensity="'+self.__intensity+'"'
            else:
                str += ' intensity="'+self.__intensity[0]+'"'
        if self.__on is not None:
            if isinstance(self.__on, six.string_types):
                str += ' on="'+self.__on+'"'
            else:
                str += ' on="'+self.__on[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DLightNode>'
        return str


class X3DMaterialNode(X3DAppearanceChildNode):
    def __init__(self, **kwargs):
        super(X3DMaterialNode, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DMaterialNode'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DMaterialNode>'
        return str


class X3DNBodyCollidableNode(X3DBoundedObject, X3DChildNode):
    def __init__(self, **kwargs):
        super(X3DNBodyCollidableNode, self).__init__(**kwargs)
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        rotation  = kwargs.pop("rotation", [0, 0, 1, 0])
        self.__rotation = rotation
        translation  = kwargs.pop("translation", [0, 0, 0])
        self.__translation = translation
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def rotation(self):
        return self.__rotation
    @rotation.setter
    def rotation(self, value = [0, 0, 1, 0]):
        self.__rotation = [value]
    def setRotation(self, rotation = [0, 0, 1, 0]):
        self.__rotation = [rotation]
        return self
    def addRotation(self, rotation = [0, 0, 1, 0]):
        if self.__rotation == None:            self.__rotation =  []
        self.__rotation +=  [rotation]
        return self
    def removeRotation(self, rotation):
        self.__rotation = [x for x in self.__rotation if x not in rotation]
        return self.__rotation
    def getRotation(self, rotation = [0, 0, 1, 0]):
        return self.__rotation
    def rotation_changed(self, rotation = [0, 0, 1, 0]):
        return self.__rotation
    @property
    def translation(self):
        return self.__translation
    @translation.setter
    def translation(self, value = [0, 0, 0]):
        self.__translation = [value]
    def setTranslation(self, translation = [0, 0, 0]):
        self.__translation = [translation]
        return self
    def addTranslation(self, translation = [0, 0, 0]):
        if self.__translation == None:            self.__translation =  []
        self.__translation +=  [translation]
        return self
    def removeTranslation(self, translation):
        self.__translation = [x for x in self.__translation if x not in translation]
        return self.__translation
    def getTranslation(self, translation = [0, 0, 0]):
        return self.__translation
    def translation_changed(self, translation = [0, 0, 0]):
        return self.__translation
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DNBodyCollidableNode'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__rotation is not None:
            if isinstance(self.__rotation, six.string_types):
                str += ' rotation="'+self.__rotation+'"'
            else:
                str += ' rotation="'+self.__rotation[0]+'"'
        if self.__translation is not None:
            if isinstance(self.__translation, six.string_types):
                str += ' translation="'+self.__translation+'"'
            else:
                str += ' translation="'+self.__translation[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DNBodyCollidableNode>'
        return str


class X3DNBodyCollisionSpaceNode(X3DBoundedObject, X3DNode):
    def __init__(self, **kwargs):
        super(X3DNBodyCollisionSpaceNode, self).__init__(**kwargs)
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DNBodyCollisionSpaceNode'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DNBodyCollisionSpaceNode>'
        return str


class X3DNetworkSensorNode(X3DSensorNode):
    def __init__(self, **kwargs):
        super(X3DNetworkSensorNode, self).__init__(**kwargs)
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    def isActive(self, Active = None):
        return self.__Active
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DNetworkSensorNode'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DNetworkSensorNode>'
        return str


class X3DNormalNode(X3DGeometricPropertyNode):
    def __init__(self, **kwargs):
        super(X3DNormalNode, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DNormalNode'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DNormalNode>'
        return str


class X3DNurbsControlCurveNode(X3DNode):
    def __init__(self, **kwargs):
        super(X3DNurbsControlCurveNode, self).__init__(**kwargs)
        controlPoint  = kwargs.pop("controlPoint", None)
        self.__controlPoint = controlPoint
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def controlPoint(self):
        return self.__controlPoint
    @controlPoint.setter
    def controlPoint(self, value = None):
        self.__controlPoint = [value]
    def setControlPoint(self, controlPoint = None):
        self.__controlPoint = [controlPoint]
        return self
    def addControlPoint(self, controlPoint = None):
        if self.__controlPoint == None:            self.__controlPoint =  []
        self.__controlPoint +=  [controlPoint]
        return self
    def removeControlPoint(self, controlPoint):
        self.__controlPoint = [x for x in self.__controlPoint if x not in controlPoint]
        return self.__controlPoint
    def getControlPoint(self, controlPoint = None):
        return self.__controlPoint
    def controlPoint_changed(self, controlPoint = None):
        return self.__controlPoint
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DNurbsControlCurveNode'
        if self.__controlPoint is not None:
            if isinstance(self.__controlPoint, six.string_types):
                str += ' controlPoint="'+self.__controlPoint+'"'
            else:
                str += ' controlPoint="'+self.__controlPoint[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DNurbsControlCurveNode>'
        return str


class X3DParametricGeometryNode(X3DGeometryNode):
    def __init__(self, **kwargs):
        super(X3DParametricGeometryNode, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DParametricGeometryNode'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DParametricGeometryNode>'
        return str


class X3DNurbsSurfaceGeometryNode(X3DParametricGeometryNode):
    def __init__(self, **kwargs):
        super(X3DNurbsSurfaceGeometryNode, self).__init__(**kwargs)
        controlPoint  = kwargs.pop("controlPoint", None)
        self.__controlPoint = controlPoint
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        solid  = kwargs.pop("solid", True)
        self.__solid = solid
        texCoord  = kwargs.pop("texCoord", None)
        self.__texCoord = texCoord
        uClosed  = kwargs.pop("uClosed", False)
        self.__uClosed = uClosed
        uDimension  = kwargs.pop("uDimension", 0)
        if uDimension == None or uDimension  <  0:
            return None
        self.__uDimension = uDimension
        uKnot  = kwargs.pop("uKnot", None)
        self.__uKnot = uKnot
        uOrder  = kwargs.pop("uOrder", 3)
        if uOrder == None or uOrder  <  2:
            return None
        self.__uOrder = uOrder
        uTessellation  = kwargs.pop("uTessellation", 0)
        self.__uTessellation = uTessellation
        vClosed  = kwargs.pop("vClosed", False)
        self.__vClosed = vClosed
        vDimension  = kwargs.pop("vDimension", 0)
        if vDimension == None or vDimension  <  0:
            return None
        self.__vDimension = vDimension
        vKnot  = kwargs.pop("vKnot", None)
        self.__vKnot = vKnot
        vOrder  = kwargs.pop("vOrder", 3)
        if vOrder == None or vOrder  <  2:
            return None
        self.__vOrder = vOrder
        vTessellation  = kwargs.pop("vTessellation", 0)
        self.__vTessellation = vTessellation
        weight  = kwargs.pop("weight", None)
        if weight == None or len(weight) <= 0 or min(weight)  <=  0:
            return None
        self.__weight = weight
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def controlPoint(self):
        return self.__controlPoint
    @controlPoint.setter
    def controlPoint(self, value = None):
        self.__controlPoint = [value]
    def setControlPoint(self, controlPoint = None):
        self.__controlPoint = [controlPoint]
        return self
    def addControlPoint(self, controlPoint = None):
        if self.__controlPoint == None:            self.__controlPoint =  []
        self.__controlPoint +=  [controlPoint]
        return self
    def removeControlPoint(self, controlPoint):
        self.__controlPoint = [x for x in self.__controlPoint if x not in controlPoint]
        return self.__controlPoint
    def getControlPoint(self, controlPoint = None):
        return self.__controlPoint
    def controlPoint_changed(self, controlPoint = None):
        return self.__controlPoint
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def texCoord(self):
        return self.__texCoord
    @texCoord.setter
    def texCoord(self, value = None):
        self.__texCoord = [value]
    def setTexCoord(self, texCoord = None):
        self.__texCoord = [texCoord]
        return self
    def addTexCoord(self, texCoord = None):
        if self.__texCoord == None:            self.__texCoord =  []
        self.__texCoord +=  [texCoord]
        return self
    def removeTexCoord(self, texCoord):
        self.__texCoord = [x for x in self.__texCoord if x not in texCoord]
        return self.__texCoord
    def getTexCoord(self, texCoord = None):
        return self.__texCoord
    def texCoord_changed(self, texCoord = None):
        return self.__texCoord
    @property
    def uTessellation(self):
        return self.__uTessellation
    @uTessellation.setter
    def uTessellation(self, value = 0):
        self.__uTessellation = [value]
    def setUTessellation(self, uTessellation = 0):
        self.__uTessellation = [uTessellation]
        return self
    def addUTessellation(self, uTessellation = 0):
        if self.__uTessellation == None:            self.__uTessellation =  []
        self.__uTessellation +=  [uTessellation]
        return self
    def removeUTessellation(self, uTessellation):
        self.__uTessellation = [x for x in self.__uTessellation if x not in uTessellation]
        return self.__uTessellation
    def getUTessellation(self, uTessellation = 0):
        return self.__uTessellation
    def uTessellation_changed(self, uTessellation = 0):
        return self.__uTessellation
    @property
    def vTessellation(self):
        return self.__vTessellation
    @vTessellation.setter
    def vTessellation(self, value = 0):
        self.__vTessellation = [value]
    def setVTessellation(self, vTessellation = 0):
        self.__vTessellation = [vTessellation]
        return self
    def addVTessellation(self, vTessellation = 0):
        if self.__vTessellation == None:            self.__vTessellation =  []
        self.__vTessellation +=  [vTessellation]
        return self
    def removeVTessellation(self, vTessellation):
        self.__vTessellation = [x for x in self.__vTessellation if x not in vTessellation]
        return self.__vTessellation
    def getVTessellation(self, vTessellation = 0):
        return self.__vTessellation
    def vTessellation_changed(self, vTessellation = 0):
        return self.__vTessellation
    @property
    def weight(self):
        return self.__weight
    @weight.setter
    def weight(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <=  0:
            return None
        self.__weight = [value]
    def setWeight(self, weight = None):
        if weight == None or len(weight) <= 0 or min(weight)  <=  0:
            return None
        self.__weight = [weight]
        return self
    def addWeight(self, weight = None):
        if weight == None or len(weight) <= 0 or min(weight)  <=  0:
            return None
        if self.__weight == None:            self.__weight =  []
        self.__weight +=  [weight]
        return self
    def removeWeight(self, weight):
        self.__weight = [x for x in self.__weight if x not in weight]
        return self.__weight
    def getWeight(self, weight = None):
        return self.__weight
    def weight_changed(self, weight = None):
        return self.__weight
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DNurbsSurfaceGeometryNode'
        if self.__solid is not None:
            if isinstance(self.__solid, six.string_types):
                str += ' solid="'+self.__solid+'"'
            else:
                str += ' solid="'+self.__solid[0]+'"'
        if self.__uClosed is not None:
            if isinstance(self.__uClosed, six.string_types):
                str += ' uClosed="'+self.__uClosed+'"'
            else:
                str += ' uClosed="'+self.__uClosed[0]+'"'
        if self.__uDimension is not None:
            if isinstance(self.__uDimension, six.string_types):
                str += ' uDimension="'+self.__uDimension+'"'
            else:
                str += ' uDimension="'+self.__uDimension[0]+'"'
        if self.__uKnot is not None:
            if isinstance(self.__uKnot, six.string_types):
                str += ' uKnot="'+self.__uKnot+'"'
            else:
                str += ' uKnot="'+self.__uKnot[0]+'"'
        if self.__uOrder is not None:
            if isinstance(self.__uOrder, six.string_types):
                str += ' uOrder="'+self.__uOrder+'"'
            else:
                str += ' uOrder="'+self.__uOrder[0]+'"'
        if self.__uTessellation is not None:
            if isinstance(self.__uTessellation, six.string_types):
                str += ' uTessellation="'+self.__uTessellation+'"'
            else:
                str += ' uTessellation="'+self.__uTessellation[0]+'"'
        if self.__vClosed is not None:
            if isinstance(self.__vClosed, six.string_types):
                str += ' vClosed="'+self.__vClosed+'"'
            else:
                str += ' vClosed="'+self.__vClosed[0]+'"'
        if self.__vDimension is not None:
            if isinstance(self.__vDimension, six.string_types):
                str += ' vDimension="'+self.__vDimension+'"'
            else:
                str += ' vDimension="'+self.__vDimension[0]+'"'
        if self.__vKnot is not None:
            if isinstance(self.__vKnot, six.string_types):
                str += ' vKnot="'+self.__vKnot+'"'
            else:
                str += ' vKnot="'+self.__vKnot[0]+'"'
        if self.__vOrder is not None:
            if isinstance(self.__vOrder, six.string_types):
                str += ' vOrder="'+self.__vOrder+'"'
            else:
                str += ' vOrder="'+self.__vOrder[0]+'"'
        if self.__vTessellation is not None:
            if isinstance(self.__vTessellation, six.string_types):
                str += ' vTessellation="'+self.__vTessellation+'"'
            else:
                str += ' vTessellation="'+self.__vTessellation[0]+'"'
        if self.__weight is not None:
            if isinstance(self.__weight, six.string_types):
                str += ' weight="'+self.__weight+'"'
            else:
                str += ' weight="'+self.__weight[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<controlPoint'
        if self.__controlPoint is not None:
           for s in self.__controlPoint:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__controlPoint is not None:
           for s in self.__controlPoint:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</controlPoint>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<texCoord'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</texCoord>'
        str += '</X3DNurbsSurfaceGeometryNode>'
        return str


class X3DParticleEmitterNode(X3DNode):
    def __init__(self, **kwargs):
        super(X3DParticleEmitterNode, self).__init__(**kwargs)
        mass  = kwargs.pop("mass", 0)
        if mass == None or mass  <  0:
            return None
        self.__mass = mass
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        speed  = kwargs.pop("speed", 0)
        if speed == None or speed  <  0:
            return None
        self.__speed = speed
        surfaceArea  = kwargs.pop("surfaceArea", 0)
        if surfaceArea == None or surfaceArea  <  0:
            return None
        self.__surfaceArea = surfaceArea
        variation  = kwargs.pop("variation", 0.25)
        if variation == None or variation  <  0:
            return None
        self.__variation = variation
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def mass(self):
        return self.__mass
    @mass.setter
    def mass(self, value = 0):
        if value == None or value  <  0:
            return None
        self.__mass = [value]
    def setMass(self, mass = 0):
        if mass == None or mass  <  0:
            return None
        self.__mass = [mass]
        return self
    def addMass(self, mass = 0):
        if mass == None or mass  <  0:
            return None
        if self.__mass == None:            self.__mass =  []
        self.__mass +=  [mass]
        return self
    def removeMass(self, mass):
        self.__mass = [x for x in self.__mass if x not in mass]
        return self.__mass
    def getMass(self, mass = 0):
        return self.__mass
    def mass_changed(self, mass = 0):
        return self.__mass
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def speed(self):
        return self.__speed
    @speed.setter
    def speed(self, value = 0):
        if value == None or value  <  0:
            return None
        self.__speed = [value]
    def setSpeed(self, speed = 0):
        if speed == None or speed  <  0:
            return None
        self.__speed = [speed]
        return self
    def addSpeed(self, speed = 0):
        if speed == None or speed  <  0:
            return None
        if self.__speed == None:            self.__speed =  []
        self.__speed +=  [speed]
        return self
    def removeSpeed(self, speed):
        self.__speed = [x for x in self.__speed if x not in speed]
        return self.__speed
    def getSpeed(self, speed = 0):
        return self.__speed
    def speed_changed(self, speed = 0):
        return self.__speed
    @property
    def variation(self):
        return self.__variation
    @variation.setter
    def variation(self, value = 0.25):
        if value == None or value  <  0:
            return None
        self.__variation = [value]
    def setVariation(self, variation = 0.25):
        if variation == None or variation  <  0:
            return None
        self.__variation = [variation]
        return self
    def addVariation(self, variation = 0.25):
        if variation == None or variation  <  0:
            return None
        if self.__variation == None:            self.__variation =  []
        self.__variation +=  [variation]
        return self
    def removeVariation(self, variation):
        self.__variation = [x for x in self.__variation if x not in variation]
        return self.__variation
    def getVariation(self, variation = 0.25):
        return self.__variation
    def variation_changed(self, variation = 0.25):
        return self.__variation
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DParticleEmitterNode'
        if self.__mass is not None:
            if isinstance(self.__mass, six.string_types):
                str += ' mass="'+self.__mass+'"'
            else:
                str += ' mass="'+self.__mass[0]+'"'
        if self.__speed is not None:
            if isinstance(self.__speed, six.string_types):
                str += ' speed="'+self.__speed+'"'
            else:
                str += ' speed="'+self.__speed[0]+'"'
        if self.__surfaceArea is not None:
            if isinstance(self.__surfaceArea, six.string_types):
                str += ' surfaceArea="'+self.__surfaceArea+'"'
            else:
                str += ' surfaceArea="'+self.__surfaceArea[0]+'"'
        if self.__variation is not None:
            if isinstance(self.__variation, six.string_types):
                str += ' variation="'+self.__variation+'"'
            else:
                str += ' variation="'+self.__variation[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DParticleEmitterNode>'
        return str


class X3DParticlePhysicsModelNode(X3DNode):
    def __init__(self, **kwargs):
        super(X3DParticlePhysicsModelNode, self).__init__(**kwargs)
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DParticlePhysicsModelNode'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DParticlePhysicsModelNode>'
        return str


class X3DPickSensorNode(X3DSensorNode):
    def __init__(self, **kwargs):
        super(X3DPickSensorNode, self).__init__(**kwargs)
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        intersectionType  = kwargs.pop("intersectionType", "BOUNDS")
        self.__intersectionType = intersectionType
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        matchCriterion  = kwargs.pop("matchCriterion", "MATCH_ANY")
        if 'MATCH_ANY' == matchCriterion:
            pass
        elif 'MATCH_EVERY' == matchCriterion:
            pass
        elif 'MATCH_ONLY_ONE' == matchCriterion:
            pass
        else:
            return None
        self.__matchCriterion = matchCriterion
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        objectType  = kwargs.pop("objectType", ["ALL"])
        self.__objectType = objectType
        pickedGeometry  = kwargs.pop("pickedGeometry", None)
        self.__pickedGeometry = pickedGeometry
        pickingGeometry  = kwargs.pop("pickingGeometry", None)
        self.__pickingGeometry = pickingGeometry
        pickTarget  = kwargs.pop("pickTarget", None)
        self.__pickTarget = pickTarget
        sortOrder  = kwargs.pop("sortOrder", "CLOSEST")
        self.__sortOrder = sortOrder
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    def isActive(self, Active = None):
        return self.__Active
    @property
    def matchCriterion(self):
        return self.__matchCriterion
    @matchCriterion.setter
    def matchCriterion(self, value = "MATCH_ANY"):
        if 'MATCH_ANY' == value:
            pass
        elif 'MATCH_EVERY' == value:
            pass
        elif 'MATCH_ONLY_ONE' == value:
            pass
        else:
            return None
        self.__matchCriterion = [value]
    def setMatchCriterion(self, matchCriterion = "MATCH_ANY"):
        if 'MATCH_ANY' == matchCriterion:
            pass
        elif 'MATCH_EVERY' == matchCriterion:
            pass
        elif 'MATCH_ONLY_ONE' == matchCriterion:
            pass
        else:
            return None
        self.__matchCriterion = [matchCriterion]
        return self
    def addMatchCriterion(self, matchCriterion = "MATCH_ANY"):
        if 'MATCH_ANY' == matchCriterion:
            pass
        elif 'MATCH_EVERY' == matchCriterion:
            pass
        elif 'MATCH_ONLY_ONE' == matchCriterion:
            pass
        else:
            return None
        if self.__matchCriterion == None:            self.__matchCriterion =  []
        self.__matchCriterion +=  [matchCriterion]
        return self
    def removeMatchCriterion(self, matchCriterion):
        self.__matchCriterion = [x for x in self.__matchCriterion if x not in matchCriterion]
        return self.__matchCriterion
    def getMatchCriterion(self, matchCriterion = "MATCH_ANY"):
        return self.__matchCriterion
    def matchCriterion_changed(self, matchCriterion = "MATCH_ANY"):
        return self.__matchCriterion
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def objectType(self):
        return self.__objectType
    @objectType.setter
    def objectType(self, value = ["ALL"]):
        self.__objectType = [value]
    def setObjectType(self, objectType = ["ALL"]):
        self.__objectType = [objectType]
        return self
    def addObjectType(self, objectType = ["ALL"]):
        if self.__objectType == None:            self.__objectType =  []
        self.__objectType +=  [objectType]
        return self
    def removeObjectType(self, objectType):
        self.__objectType = [x for x in self.__objectType if x not in objectType]
        return self.__objectType
    def getObjectType(self, objectType = ["ALL"]):
        return self.__objectType
    def objectType_changed(self, objectType = ["ALL"]):
        return self.__objectType
    def removePickedGeometry(self, pickedGeometry):
        self.__pickedGeometry = [x for x in self.__pickedGeometry if x not in pickedGeometry]
        return self.__pickedGeometry
    def getPickedGeometry(self, pickedGeometry = None):
        return self.__pickedGeometry
    def pickedGeometry_changed(self, pickedGeometry = None):
        return self.__pickedGeometry
    @property
    def pickingGeometry(self):
        return self.__pickingGeometry
    @pickingGeometry.setter
    def pickingGeometry(self, value = None):
        self.__pickingGeometry = [value]
    def setPickingGeometry(self, pickingGeometry = None):
        self.__pickingGeometry = [pickingGeometry]
        return self
    def addPickingGeometry(self, pickingGeometry = None):
        if self.__pickingGeometry == None:            self.__pickingGeometry =  []
        self.__pickingGeometry +=  [pickingGeometry]
        return self
    def removePickingGeometry(self, pickingGeometry):
        self.__pickingGeometry = [x for x in self.__pickingGeometry if x not in pickingGeometry]
        return self.__pickingGeometry
    def getPickingGeometry(self, pickingGeometry = None):
        return self.__pickingGeometry
    def pickingGeometry_changed(self, pickingGeometry = None):
        return self.__pickingGeometry
    @property
    def pickTarget(self):
        return self.__pickTarget
    @pickTarget.setter
    def pickTarget(self, value = None):
        self.__pickTarget = [value]
    def setPickTarget(self, pickTarget = None):
        self.__pickTarget = [pickTarget]
        return self
    def addPickTarget(self, pickTarget = None):
        if self.__pickTarget == None:            self.__pickTarget =  []
        self.__pickTarget +=  [pickTarget]
        return self
    def removePickTarget(self, pickTarget):
        self.__pickTarget = [x for x in self.__pickTarget if x not in pickTarget]
        return self.__pickTarget
    def getPickTarget(self, pickTarget = None):
        return self.__pickTarget
    def pickTarget_changed(self, pickTarget = None):
        return self.__pickTarget
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DPickSensorNode'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__intersectionType is not None:
            if isinstance(self.__intersectionType, six.string_types):
                str += ' intersectionType="'+self.__intersectionType+'"'
            else:
                str += ' intersectionType="'+self.__intersectionType[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__matchCriterion is not None:
            if isinstance(self.__matchCriterion, six.string_types):
                str += ' matchCriterion="'+self.__matchCriterion+'"'
            else:
                str += ' matchCriterion="'+self.__matchCriterion[0]+'"'
        if self.__objectType is not None:
            if isinstance(self.__objectType, six.string_types):
                str += ' objectType="'+self.__objectType+'"'
            else:
                str += ' objectType="'+self.__objectType[0]+'"'
        if self.__sortOrder is not None:
            if isinstance(self.__sortOrder, six.string_types):
                str += ' sortOrder="'+self.__sortOrder+'"'
            else:
                str += ' sortOrder="'+self.__sortOrder[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<pickedGeometry'
        if self.__pickedGeometry is not None:
           for s in self.__pickedGeometry:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__pickedGeometry is not None:
           for s in self.__pickedGeometry:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</pickedGeometry>'
        str += '<pickingGeometry'
        if self.__pickingGeometry is not None:
           for s in self.__pickingGeometry:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__pickingGeometry is not None:
           for s in self.__pickingGeometry:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</pickingGeometry>'
        str += '<pickTarget'
        if self.__pickTarget is not None:
           for s in self.__pickTarget:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__pickTarget is not None:
           for s in self.__pickTarget:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</pickTarget>'
        str += '</X3DPickSensorNode>'
        return str


class X3DProductStructureChildNode(X3DChildNode):
    def __init__(self, **kwargs):
        super(X3DProductStructureChildNode, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        name  = kwargs.pop("name", None)
        self.__name = name
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        self.__name = [value]
    def setName(self, name = None):
        self.__name = [name]
        return self
    def addName(self, name = None):
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DProductStructureChildNode'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DProductStructureChildNode>'
        return str


class X3DPrototypeInstance(X3DNode):
    def __init__(self, **kwargs):
        super(X3DPrototypeInstance, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DPrototypeInstance'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DPrototypeInstance>'
        return str


class X3DRigidJointNode(X3DNode):
    def __init__(self, **kwargs):
        super(X3DRigidJointNode, self).__init__(**kwargs)
        body1  = kwargs.pop("body1", None)
        self.__body1 = body1
        body2  = kwargs.pop("body2", None)
        self.__body2 = body2
        forceOutput  = kwargs.pop("forceOutput", ["NONE"])
        self.__forceOutput = forceOutput
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def body1(self):
        return self.__body1
    @body1.setter
    def body1(self, value = None):
        self.__body1 = [value]
    def setBody1(self, body1 = None):
        self.__body1 = [body1]
        return self
    def addBody1(self, body1 = None):
        if self.__body1 == None:            self.__body1 =  []
        self.__body1 +=  [body1]
        return self
    def removeBody1(self, body1):
        self.__body1 = [x for x in self.__body1 if x not in body1]
        return self.__body1
    def getBody1(self, body1 = None):
        return self.__body1
    def body1_changed(self, body1 = None):
        return self.__body1
    @property
    def body2(self):
        return self.__body2
    @body2.setter
    def body2(self, value = None):
        self.__body2 = [value]
    def setBody2(self, body2 = None):
        self.__body2 = [body2]
        return self
    def addBody2(self, body2 = None):
        if self.__body2 == None:            self.__body2 =  []
        self.__body2 +=  [body2]
        return self
    def removeBody2(self, body2):
        self.__body2 = [x for x in self.__body2 if x not in body2]
        return self.__body2
    def getBody2(self, body2 = None):
        return self.__body2
    def body2_changed(self, body2 = None):
        return self.__body2
    @property
    def forceOutput(self):
        return self.__forceOutput
    @forceOutput.setter
    def forceOutput(self, value = ["NONE"]):
        self.__forceOutput = [value]
    def setForceOutput(self, forceOutput = ["NONE"]):
        self.__forceOutput = [forceOutput]
        return self
    def addForceOutput(self, forceOutput = ["NONE"]):
        if self.__forceOutput == None:            self.__forceOutput =  []
        self.__forceOutput +=  [forceOutput]
        return self
    def removeForceOutput(self, forceOutput):
        self.__forceOutput = [x for x in self.__forceOutput if x not in forceOutput]
        return self.__forceOutput
    def getForceOutput(self, forceOutput = ["NONE"]):
        return self.__forceOutput
    def forceOutput_changed(self, forceOutput = ["NONE"]):
        return self.__forceOutput
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DRigidJointNode'
        if self.__forceOutput is not None:
            if isinstance(self.__forceOutput, six.string_types):
                str += ' forceOutput="'+self.__forceOutput+'"'
            else:
                str += ' forceOutput="'+self.__forceOutput[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<body1'
        if self.__body1 is not None:
           for s in self.__body1:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__body1 is not None:
           for s in self.__body1:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</body1>'
        str += '<body2'
        if self.__body2 is not None:
           for s in self.__body2:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__body2 is not None:
           for s in self.__body2:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</body2>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DRigidJointNode>'
        return str


class X3DUrlObject(object):
    def __init__(self, **kwargs):
        super(X3DUrlObject, self).__init__()
        url  = kwargs.pop("url", None)
        self.__url = url
    @property
    def url(self):
        return self.__url
    @url.setter
    def url(self, value = None):
        self.__url = [value]
    def setUrl(self, url = None):
        self.__url = [url]
        return self
    def addUrl(self, url = None):
        if self.__url == None:            self.__url =  []
        self.__url +=  [url]
        return self
    def removeUrl(self, url):
        self.__url = [x for x in self.__url if x not in url]
        return self.__url
    def getUrl(self, url = None):
        return self.__url
    def url_changed(self, url = None):
        return self.__url
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DUrlObject'
        if self.__url is not None:
            if isinstance(self.__url, six.string_types):
                str += ' url="'+self.__url+'"'
            else:
                str += ' url="'+self.__url[0]+'"'
        str += '>'
        str += '</X3DUrlObject>'
        return str


class X3DScriptNode(X3DUrlObject, X3DChildNode):
    def __init__(self, **kwargs):
        super(X3DScriptNode, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        url  = kwargs.pop("url", None)
        self.__url = url
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def url(self):
        return self.__url
    @url.setter
    def url(self, value = None):
        self.__url = [value]
    def setUrl(self, url = None):
        self.__url = [url]
        return self
    def addUrl(self, url = None):
        if self.__url == None:            self.__url =  []
        self.__url +=  [url]
        return self
    def removeUrl(self, url):
        self.__url = [x for x in self.__url if x not in url]
        return self.__url
    def getUrl(self, url = None):
        return self.__url
    def url_changed(self, url = None):
        return self.__url
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DScriptNode'
        if self.__url is not None:
            if isinstance(self.__url, six.string_types):
                str += ' url="'+self.__url+'"'
            else:
                str += ' url="'+self.__url[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DScriptNode>'
        return str


class X3DSequencerNode(X3DChildNode):
    def __init__(self, **kwargs):
        super(X3DSequencerNode, self).__init__(**kwargs)
        key  = kwargs.pop("key", None)
        self.__key = key
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        next  = kwargs.pop("next", None)
        self.__next = next
        previous  = kwargs.pop("previous", None)
        self.__previous = previous
        fraction  = kwargs.pop("fraction", None)
        self.__fraction = fraction
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def key(self):
        return self.__key
    @key.setter
    def key(self, value = None):
        self.__key = [value]
    def setKey(self, key = None):
        self.__key = [key]
        return self
    def addKey(self, key = None):
        if self.__key == None:            self.__key =  []
        self.__key +=  [key]
        return self
    def removeKey(self, key):
        self.__key = [x for x in self.__key if x not in key]
        return self.__key
    def getKey(self, key = None):
        return self.__key
    def key_changed(self, key = None):
        return self.__key
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def next(self):
        return self.__next
    @next.setter
    def next(self, value = None):
        self.__next = [value]
    def setNext(self, next = None):
        self.__next = [next]
        return self
    def addNext(self, next = None):
        if self.__next == None:            self.__next =  []
        self.__next +=  [next]
        return self
    @property
    def previous(self):
        return self.__previous
    @previous.setter
    def previous(self, value = None):
        self.__previous = [value]
    def setPrevious(self, previous = None):
        self.__previous = [previous]
        return self
    def addPrevious(self, previous = None):
        if self.__previous == None:            self.__previous =  []
        self.__previous +=  [previous]
        return self
    @property
    def fraction(self):
        return self.__fraction
    @fraction.setter
    def fraction(self, value = None):
        self.__fraction = [value]
    def set_fraction(self, fraction = None):
        self.__fraction = [fraction]
        return self
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DSequencerNode'
        if self.__key is not None:
            if isinstance(self.__key, six.string_types):
                str += ' key="'+self.__key+'"'
            else:
                str += ' key="'+self.__key[0]+'"'
        if self.__next is not None:
            if isinstance(self.__next, six.string_types):
                str += ' next="'+self.__next+'"'
            else:
                str += ' next="'+self.__next[0]+'"'
        if self.__previous is not None:
            if isinstance(self.__previous, six.string_types):
                str += ' previous="'+self.__previous+'"'
            else:
                str += ' previous="'+self.__previous[0]+'"'
        if self.__fraction is not None:
            if isinstance(self.__fraction, six.string_types):
                str += ' fraction="'+self.__fraction+'"'
            else:
                str += ' fraction="'+self.__fraction[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DSequencerNode>'
        return str


class X3DShaderNode(X3DAppearanceChildNode):
    def __init__(self, **kwargs):
        super(X3DShaderNode, self).__init__(**kwargs)
        activate  = kwargs.pop("activate", None)
        self.__activate = activate
        Selected  = kwargs.pop("Selected", None)
        self.__Selected = Selected
        Valid  = kwargs.pop("Valid", None)
        self.__Valid = Valid
        language  = kwargs.pop("language", None)
        self.__language = language
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def activate(self):
        return self.__activate
    @activate.setter
    def activate(self, value = None):
        self.__activate = [value]
    def setActivate(self, activate = None):
        self.__activate = [activate]
        return self
    def addActivate(self, activate = None):
        if self.__activate == None:            self.__activate =  []
        self.__activate +=  [activate]
        return self
    def isSelected(self, Selected = None):
        return self.__Selected
    def isValid(self, Valid = None):
        return self.__Valid
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DShaderNode'
        if self.__activate is not None:
            if isinstance(self.__activate, six.string_types):
                str += ' activate="'+self.__activate+'"'
            else:
                str += ' activate="'+self.__activate[0]+'"'
        if self.__Selected is not None:
            if isinstance(self.__Selected, six.string_types):
                str += ' Selected="'+self.__Selected+'"'
            else:
                str += ' Selected="'+self.__Selected[0]+'"'
        if self.__Valid is not None:
            if isinstance(self.__Valid, six.string_types):
                str += ' Valid="'+self.__Valid+'"'
            else:
                str += ' Valid="'+self.__Valid[0]+'"'
        if self.__language is not None:
            if isinstance(self.__language, six.string_types):
                str += ' language="'+self.__language+'"'
            else:
                str += ' language="'+self.__language[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DShaderNode>'
        return str


class X3DShapeNode(X3DBoundedObject, X3DChildNode):
    def __init__(self, **kwargs):
        super(X3DShapeNode, self).__init__(**kwargs)
        appearance  = kwargs.pop("appearance", None)
        self.__appearance = appearance
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        geometry  = kwargs.pop("geometry", None)
        self.__geometry = geometry
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def appearance(self):
        return self.__appearance
    @appearance.setter
    def appearance(self, value = None):
        self.__appearance = [value]
    def setAppearance(self, appearance = None):
        self.__appearance = [appearance]
        return self
    def addAppearance(self, appearance = None):
        if self.__appearance == None:            self.__appearance =  []
        self.__appearance +=  [appearance]
        return self
    def removeAppearance(self, appearance):
        self.__appearance = [x for x in self.__appearance if x not in appearance]
        return self.__appearance
    def getAppearance(self, appearance = None):
        return self.__appearance
    def appearance_changed(self, appearance = None):
        return self.__appearance
    @property
    def geometry(self):
        return self.__geometry
    @geometry.setter
    def geometry(self, value = None):
        self.__geometry = [value]
    def setGeometry(self, geometry = None):
        self.__geometry = [geometry]
        return self
    def addGeometry(self, geometry = None):
        if self.__geometry == None:            self.__geometry =  []
        self.__geometry +=  [geometry]
        return self
    def removeGeometry(self, geometry):
        self.__geometry = [x for x in self.__geometry if x not in geometry]
        return self.__geometry
    def getGeometry(self, geometry = None):
        return self.__geometry
    def geometry_changed(self, geometry = None):
        return self.__geometry
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DShapeNode'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<appearance'
        if self.__appearance is not None:
           for s in self.__appearance:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__appearance is not None:
           for s in self.__appearance:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</appearance>'
        str += '<geometry'
        if self.__geometry is not None:
           for s in self.__geometry:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__geometry is not None:
           for s in self.__geometry:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</geometry>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DShapeNode>'
        return str


class X3DSoundNode(X3DChildNode):
    def __init__(self, **kwargs):
        super(X3DSoundNode, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DSoundNode'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DSoundNode>'
        return str


class X3DTimeDependentNode(X3DChildNode):
    def __init__(self, **kwargs):
        super(X3DTimeDependentNode, self).__init__(**kwargs)
        elapsedTime  = kwargs.pop("elapsedTime", None)
        if elapsedTime == None or elapsedTime  <  0:
            return None
        self.__elapsedTime = elapsedTime
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        Paused  = kwargs.pop("Paused", None)
        self.__Paused = Paused
        loop  = kwargs.pop("loop", False)
        self.__loop = loop
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        pauseTime  = kwargs.pop("pauseTime", 0)
        self.__pauseTime = pauseTime
        resumeTime  = kwargs.pop("resumeTime", 0)
        self.__resumeTime = resumeTime
        startTime  = kwargs.pop("startTime", 0)
        self.__startTime = startTime
        stopTime  = kwargs.pop("stopTime", 0)
        self.__stopTime = stopTime
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def removeElapsedTime(self, elapsedTime):
        self.__elapsedTime = [x for x in self.__elapsedTime if x not in elapsedTime]
        return self.__elapsedTime
    def getElapsedTime(self, elapsedTime = None):
        return self.__elapsedTime
    def elapsedTime_changed(self, elapsedTime = None):
        return self.__elapsedTime
    def isActive(self, Active = None):
        return self.__Active
    def isPaused(self, Paused = None):
        return self.__Paused
    @property
    def loop(self):
        return self.__loop
    @loop.setter
    def loop(self, value = False):
        self.__loop = [value]
    def setLoop(self, loop = False):
        self.__loop = [loop]
        return self
    def addLoop(self, loop = False):
        if self.__loop == None:            self.__loop =  []
        self.__loop +=  [loop]
        return self
    def removeLoop(self, loop):
        self.__loop = [x for x in self.__loop if x not in loop]
        return self.__loop
    def isLoop(self, loop = False):
        return self.__loop
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def pauseTime(self):
        return self.__pauseTime
    @pauseTime.setter
    def pauseTime(self, value = 0):
        self.__pauseTime = [value]
    def setPauseTime(self, pauseTime = 0):
        self.__pauseTime = [pauseTime]
        return self
    def addPauseTime(self, pauseTime = 0):
        if self.__pauseTime == None:            self.__pauseTime =  []
        self.__pauseTime +=  [pauseTime]
        return self
    def removePauseTime(self, pauseTime):
        self.__pauseTime = [x for x in self.__pauseTime if x not in pauseTime]
        return self.__pauseTime
    def getPauseTime(self, pauseTime = 0):
        return self.__pauseTime
    def pauseTime_changed(self, pauseTime = 0):
        return self.__pauseTime
    @property
    def resumeTime(self):
        return self.__resumeTime
    @resumeTime.setter
    def resumeTime(self, value = 0):
        self.__resumeTime = [value]
    def setResumeTime(self, resumeTime = 0):
        self.__resumeTime = [resumeTime]
        return self
    def addResumeTime(self, resumeTime = 0):
        if self.__resumeTime == None:            self.__resumeTime =  []
        self.__resumeTime +=  [resumeTime]
        return self
    def removeResumeTime(self, resumeTime):
        self.__resumeTime = [x for x in self.__resumeTime if x not in resumeTime]
        return self.__resumeTime
    def getResumeTime(self, resumeTime = 0):
        return self.__resumeTime
    def resumeTime_changed(self, resumeTime = 0):
        return self.__resumeTime
    @property
    def startTime(self):
        return self.__startTime
    @startTime.setter
    def startTime(self, value = 0):
        self.__startTime = [value]
    def setStartTime(self, startTime = 0):
        self.__startTime = [startTime]
        return self
    def addStartTime(self, startTime = 0):
        if self.__startTime == None:            self.__startTime =  []
        self.__startTime +=  [startTime]
        return self
    def removeStartTime(self, startTime):
        self.__startTime = [x for x in self.__startTime if x not in startTime]
        return self.__startTime
    def getStartTime(self, startTime = 0):
        return self.__startTime
    def startTime_changed(self, startTime = 0):
        return self.__startTime
    @property
    def stopTime(self):
        return self.__stopTime
    @stopTime.setter
    def stopTime(self, value = 0):
        self.__stopTime = [value]
    def setStopTime(self, stopTime = 0):
        self.__stopTime = [stopTime]
        return self
    def addStopTime(self, stopTime = 0):
        if self.__stopTime == None:            self.__stopTime =  []
        self.__stopTime +=  [stopTime]
        return self
    def removeStopTime(self, stopTime):
        self.__stopTime = [x for x in self.__stopTime if x not in stopTime]
        return self.__stopTime
    def getStopTime(self, stopTime = 0):
        return self.__stopTime
    def stopTime_changed(self, stopTime = 0):
        return self.__stopTime
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DTimeDependentNode'
        if self.__elapsedTime is not None:
            if isinstance(self.__elapsedTime, six.string_types):
                str += ' elapsedTime="'+self.__elapsedTime+'"'
            else:
                str += ' elapsedTime="'+self.__elapsedTime[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__Paused is not None:
            if isinstance(self.__Paused, six.string_types):
                str += ' Paused="'+self.__Paused+'"'
            else:
                str += ' Paused="'+self.__Paused[0]+'"'
        if self.__loop is not None:
            if isinstance(self.__loop, six.string_types):
                str += ' loop="'+self.__loop+'"'
            else:
                str += ' loop="'+self.__loop[0]+'"'
        if self.__pauseTime is not None:
            if isinstance(self.__pauseTime, six.string_types):
                str += ' pauseTime="'+self.__pauseTime+'"'
            else:
                str += ' pauseTime="'+self.__pauseTime[0]+'"'
        if self.__resumeTime is not None:
            if isinstance(self.__resumeTime, six.string_types):
                str += ' resumeTime="'+self.__resumeTime+'"'
            else:
                str += ' resumeTime="'+self.__resumeTime[0]+'"'
        if self.__startTime is not None:
            if isinstance(self.__startTime, six.string_types):
                str += ' startTime="'+self.__startTime+'"'
            else:
                str += ' startTime="'+self.__startTime[0]+'"'
        if self.__stopTime is not None:
            if isinstance(self.__stopTime, six.string_types):
                str += ' stopTime="'+self.__stopTime+'"'
            else:
                str += ' stopTime="'+self.__stopTime[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DTimeDependentNode>'
        return str


class X3DSoundSourceNode(X3DTimeDependentNode):
    def __init__(self, **kwargs):
        super(X3DSoundSourceNode, self).__init__(**kwargs)
        description  = kwargs.pop("description", None)
        self.__description = description
        duration_changed  = kwargs.pop("duration_changed", None)
        if duration_changed == None or duration_changed  <  -1:
            return None
        self.__duration_changed = duration_changed
        elapsedTime  = kwargs.pop("elapsedTime", None)
        if elapsedTime == None or elapsedTime  <  0:
            return None
        self.__elapsedTime = elapsedTime
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        Paused  = kwargs.pop("Paused", None)
        self.__Paused = Paused
        loop  = kwargs.pop("loop", False)
        self.__loop = loop
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        pauseTime  = kwargs.pop("pauseTime", 0)
        self.__pauseTime = pauseTime
        pitch  = kwargs.pop("pitch", 1.0)
        if pitch == None or pitch  <=  0:
            return None
        self.__pitch = pitch
        resumeTime  = kwargs.pop("resumeTime", 0)
        self.__resumeTime = resumeTime
        startTime  = kwargs.pop("startTime", 0)
        self.__startTime = startTime
        stopTime  = kwargs.pop("stopTime", 0)
        self.__stopTime = stopTime
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def description(self):
        return self.__description
    @description.setter
    def description(self, value = None):
        self.__description = [value]
    def setDescription(self, description = None):
        self.__description = [description]
        return self
    def addDescription(self, description = None):
        if self.__description == None:            self.__description =  []
        self.__description +=  [description]
        return self
    def removeDescription(self, description):
        self.__description = [x for x in self.__description if x not in description]
        return self.__description
    def getDescription(self, description = None):
        return self.__description
    def description_changed(self, description = None):
        return self.__description
    def removeduration_changed(self, duration_changed):
        self.__duration_changed = [x for x in self.__duration_changed if x not in duration_changed]
        return self.__duration_changed
    def getduration_changed(self, duration_changed = None):
        return self.__duration_changed
    def duration_changed_changed(self, duration_changed = None):
        return self.__duration_changed
    def removeElapsedTime(self, elapsedTime):
        self.__elapsedTime = [x for x in self.__elapsedTime if x not in elapsedTime]
        return self.__elapsedTime
    def getElapsedTime(self, elapsedTime = None):
        return self.__elapsedTime
    def elapsedTime_changed(self, elapsedTime = None):
        return self.__elapsedTime
    def isActive(self, Active = None):
        return self.__Active
    def isPaused(self, Paused = None):
        return self.__Paused
    @property
    def loop(self):
        return self.__loop
    @loop.setter
    def loop(self, value = False):
        self.__loop = [value]
    def setLoop(self, loop = False):
        self.__loop = [loop]
        return self
    def addLoop(self, loop = False):
        if self.__loop == None:            self.__loop =  []
        self.__loop +=  [loop]
        return self
    def removeLoop(self, loop):
        self.__loop = [x for x in self.__loop if x not in loop]
        return self.__loop
    def isLoop(self, loop = False):
        return self.__loop
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def pauseTime(self):
        return self.__pauseTime
    @pauseTime.setter
    def pauseTime(self, value = 0):
        self.__pauseTime = [value]
    def setPauseTime(self, pauseTime = 0):
        self.__pauseTime = [pauseTime]
        return self
    def addPauseTime(self, pauseTime = 0):
        if self.__pauseTime == None:            self.__pauseTime =  []
        self.__pauseTime +=  [pauseTime]
        return self
    def removePauseTime(self, pauseTime):
        self.__pauseTime = [x for x in self.__pauseTime if x not in pauseTime]
        return self.__pauseTime
    def getPauseTime(self, pauseTime = 0):
        return self.__pauseTime
    def pauseTime_changed(self, pauseTime = 0):
        return self.__pauseTime
    @property
    def pitch(self):
        return self.__pitch
    @pitch.setter
    def pitch(self, value = 1.0):
        if value == None or value  <=  0:
            return None
        self.__pitch = [value]
    def setPitch(self, pitch = 1.0):
        if pitch == None or pitch  <=  0:
            return None
        self.__pitch = [pitch]
        return self
    def addPitch(self, pitch = 1.0):
        if pitch == None or pitch  <=  0:
            return None
        if self.__pitch == None:            self.__pitch =  []
        self.__pitch +=  [pitch]
        return self
    def removePitch(self, pitch):
        self.__pitch = [x for x in self.__pitch if x not in pitch]
        return self.__pitch
    def getPitch(self, pitch = 1.0):
        return self.__pitch
    def pitch_changed(self, pitch = 1.0):
        return self.__pitch
    @property
    def resumeTime(self):
        return self.__resumeTime
    @resumeTime.setter
    def resumeTime(self, value = 0):
        self.__resumeTime = [value]
    def setResumeTime(self, resumeTime = 0):
        self.__resumeTime = [resumeTime]
        return self
    def addResumeTime(self, resumeTime = 0):
        if self.__resumeTime == None:            self.__resumeTime =  []
        self.__resumeTime +=  [resumeTime]
        return self
    def removeResumeTime(self, resumeTime):
        self.__resumeTime = [x for x in self.__resumeTime if x not in resumeTime]
        return self.__resumeTime
    def getResumeTime(self, resumeTime = 0):
        return self.__resumeTime
    def resumeTime_changed(self, resumeTime = 0):
        return self.__resumeTime
    @property
    def startTime(self):
        return self.__startTime
    @startTime.setter
    def startTime(self, value = 0):
        self.__startTime = [value]
    def setStartTime(self, startTime = 0):
        self.__startTime = [startTime]
        return self
    def addStartTime(self, startTime = 0):
        if self.__startTime == None:            self.__startTime =  []
        self.__startTime +=  [startTime]
        return self
    def removeStartTime(self, startTime):
        self.__startTime = [x for x in self.__startTime if x not in startTime]
        return self.__startTime
    def getStartTime(self, startTime = 0):
        return self.__startTime
    def startTime_changed(self, startTime = 0):
        return self.__startTime
    @property
    def stopTime(self):
        return self.__stopTime
    @stopTime.setter
    def stopTime(self, value = 0):
        self.__stopTime = [value]
    def setStopTime(self, stopTime = 0):
        self.__stopTime = [stopTime]
        return self
    def addStopTime(self, stopTime = 0):
        if self.__stopTime == None:            self.__stopTime =  []
        self.__stopTime +=  [stopTime]
        return self
    def removeStopTime(self, stopTime):
        self.__stopTime = [x for x in self.__stopTime if x not in stopTime]
        return self.__stopTime
    def getStopTime(self, stopTime = 0):
        return self.__stopTime
    def stopTime_changed(self, stopTime = 0):
        return self.__stopTime
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DSoundSourceNode'
        if self.__description is not None:
            if isinstance(self.__description, six.string_types):
                str += ' description="'+self.__description+'"'
            else:
                str += ' description="'+self.__description[0]+'"'
        if self.__duration_changed is not None:
            if isinstance(self.__duration_changed, six.string_types):
                str += ' duration_changed="'+self.__duration_changed+'"'
            else:
                str += ' duration_changed="'+self.__duration_changed[0]+'"'
        if self.__elapsedTime is not None:
            if isinstance(self.__elapsedTime, six.string_types):
                str += ' elapsedTime="'+self.__elapsedTime+'"'
            else:
                str += ' elapsedTime="'+self.__elapsedTime[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__Paused is not None:
            if isinstance(self.__Paused, six.string_types):
                str += ' Paused="'+self.__Paused+'"'
            else:
                str += ' Paused="'+self.__Paused[0]+'"'
        if self.__loop is not None:
            if isinstance(self.__loop, six.string_types):
                str += ' loop="'+self.__loop+'"'
            else:
                str += ' loop="'+self.__loop[0]+'"'
        if self.__pauseTime is not None:
            if isinstance(self.__pauseTime, six.string_types):
                str += ' pauseTime="'+self.__pauseTime+'"'
            else:
                str += ' pauseTime="'+self.__pauseTime[0]+'"'
        if self.__pitch is not None:
            if isinstance(self.__pitch, six.string_types):
                str += ' pitch="'+self.__pitch+'"'
            else:
                str += ' pitch="'+self.__pitch[0]+'"'
        if self.__resumeTime is not None:
            if isinstance(self.__resumeTime, six.string_types):
                str += ' resumeTime="'+self.__resumeTime+'"'
            else:
                str += ' resumeTime="'+self.__resumeTime[0]+'"'
        if self.__startTime is not None:
            if isinstance(self.__startTime, six.string_types):
                str += ' startTime="'+self.__startTime+'"'
            else:
                str += ' startTime="'+self.__startTime[0]+'"'
        if self.__stopTime is not None:
            if isinstance(self.__stopTime, six.string_types):
                str += ' stopTime="'+self.__stopTime+'"'
            else:
                str += ' stopTime="'+self.__stopTime[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DSoundSourceNode>'
        return str


class X3DTexture2DNode(X3DTextureNode):
    def __init__(self, **kwargs):
        super(X3DTexture2DNode, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        repeatS  = kwargs.pop("repeatS", True)
        self.__repeatS = repeatS
        repeatT  = kwargs.pop("repeatT", True)
        self.__repeatT = repeatT
        textureProperties  = kwargs.pop("textureProperties", None)
        self.__textureProperties = textureProperties
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DTexture2DNode'
        if self.__repeatS is not None:
            if isinstance(self.__repeatS, six.string_types):
                str += ' repeatS="'+self.__repeatS+'"'
            else:
                str += ' repeatS="'+self.__repeatS[0]+'"'
        if self.__repeatT is not None:
            if isinstance(self.__repeatT, six.string_types):
                str += ' repeatT="'+self.__repeatT+'"'
            else:
                str += ' repeatT="'+self.__repeatT[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<textureProperties'
        if self.__textureProperties is not None:
           for s in self.__textureProperties:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__textureProperties is not None:
           for s in self.__textureProperties:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</textureProperties>'
        str += '</X3DTexture2DNode>'
        return str


class X3DTexture3DNode(X3DTextureNode):
    def __init__(self, **kwargs):
        super(X3DTexture3DNode, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        repeatR  = kwargs.pop("repeatR", False)
        self.__repeatR = repeatR
        repeatS  = kwargs.pop("repeatS", False)
        self.__repeatS = repeatS
        repeatT  = kwargs.pop("repeatT", False)
        self.__repeatT = repeatT
        textureProperties  = kwargs.pop("textureProperties", None)
        self.__textureProperties = textureProperties
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DTexture3DNode'
        if self.__repeatR is not None:
            if isinstance(self.__repeatR, six.string_types):
                str += ' repeatR="'+self.__repeatR+'"'
            else:
                str += ' repeatR="'+self.__repeatR[0]+'"'
        if self.__repeatS is not None:
            if isinstance(self.__repeatS, six.string_types):
                str += ' repeatS="'+self.__repeatS+'"'
            else:
                str += ' repeatS="'+self.__repeatS[0]+'"'
        if self.__repeatT is not None:
            if isinstance(self.__repeatT, six.string_types):
                str += ' repeatT="'+self.__repeatT+'"'
            else:
                str += ' repeatT="'+self.__repeatT[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<textureProperties'
        if self.__textureProperties is not None:
           for s in self.__textureProperties:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__textureProperties is not None:
           for s in self.__textureProperties:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</textureProperties>'
        str += '</X3DTexture3DNode>'
        return str


class X3DTextureCoordinateNode(X3DGeometricPropertyNode):
    def __init__(self, **kwargs):
        super(X3DTextureCoordinateNode, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DTextureCoordinateNode'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DTextureCoordinateNode>'
        return str


class X3DTextureTransformNode(X3DAppearanceChildNode):
    def __init__(self, **kwargs):
        super(X3DTextureTransformNode, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DTextureTransformNode'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DTextureTransformNode>'
        return str


class X3DTouchSensorNode(X3DPointingDeviceSensorNode):
    def __init__(self, **kwargs):
        super(X3DTouchSensorNode, self).__init__(**kwargs)
        description  = kwargs.pop("description", None)
        self.__description = description
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        Over  = kwargs.pop("Over", None)
        self.__Over = Over
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        touchTime  = kwargs.pop("touchTime", None)
        self.__touchTime = touchTime
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def description(self):
        return self.__description
    @description.setter
    def description(self, value = None):
        self.__description = [value]
    def setDescription(self, description = None):
        self.__description = [description]
        return self
    def addDescription(self, description = None):
        if self.__description == None:            self.__description =  []
        self.__description +=  [description]
        return self
    def removeDescription(self, description):
        self.__description = [x for x in self.__description if x not in description]
        return self.__description
    def getDescription(self, description = None):
        return self.__description
    def description_changed(self, description = None):
        return self.__description
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    def isActive(self, Active = None):
        return self.__Active
    def isOver(self, Over = None):
        return self.__Over
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    def removeTouchTime(self, touchTime):
        self.__touchTime = [x for x in self.__touchTime if x not in touchTime]
        return self.__touchTime
    def getTouchTime(self, touchTime = None):
        return self.__touchTime
    def touchTime_changed(self, touchTime = None):
        return self.__touchTime
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DTouchSensorNode'
        if self.__description is not None:
            if isinstance(self.__description, six.string_types):
                str += ' description="'+self.__description+'"'
            else:
                str += ' description="'+self.__description[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__Over is not None:
            if isinstance(self.__Over, six.string_types):
                str += ' Over="'+self.__Over+'"'
            else:
                str += ' Over="'+self.__Over[0]+'"'
        if self.__touchTime is not None:
            if isinstance(self.__touchTime, six.string_types):
                str += ' touchTime="'+self.__touchTime+'"'
            else:
                str += ' touchTime="'+self.__touchTime[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DTouchSensorNode>'
        return str


class X3DTriggerNode(X3DChildNode):
    def __init__(self, **kwargs):
        super(X3DTriggerNode, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DTriggerNode'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DTriggerNode>'
        return str


class X3DVertexAttributeNode(X3DGeometricPropertyNode):
    def __init__(self, **kwargs):
        super(X3DVertexAttributeNode, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        name  = kwargs.pop("name", None)
        self.__name = name
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        self.__name = [value]
    def setName(self, name = None):
        self.__name = [name]
        return self
    def addName(self, name = None):
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DVertexAttributeNode'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DVertexAttributeNode>'
        return str


class X3DViewpointNode(X3DBindableNode):
    def __init__(self, **kwargs):
        super(X3DViewpointNode, self).__init__(**kwargs)
        bindTime  = kwargs.pop("bindTime", None)
        self.__bindTime = bindTime
        description  = kwargs.pop("description", None)
        self.__description = description
        Bound  = kwargs.pop("Bound", None)
        self.__Bound = Bound
        jump  = kwargs.pop("jump", True)
        self.__jump = jump
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        orientation  = kwargs.pop("orientation", [0, 0, 1, 0])
        self.__orientation = orientation
        retainUserOffsets  = kwargs.pop("retainUserOffsets", False)
        self.__retainUserOffsets = retainUserOffsets
        bind  = kwargs.pop("bind", None)
        self.__bind = bind
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def removeBindTime(self, bindTime):
        self.__bindTime = [x for x in self.__bindTime if x not in bindTime]
        return self.__bindTime
    def getBindTime(self, bindTime = None):
        return self.__bindTime
    def bindTime_changed(self, bindTime = None):
        return self.__bindTime
    @property
    def description(self):
        return self.__description
    @description.setter
    def description(self, value = None):
        self.__description = [value]
    def setDescription(self, description = None):
        self.__description = [description]
        return self
    def addDescription(self, description = None):
        if self.__description == None:            self.__description =  []
        self.__description +=  [description]
        return self
    def removeDescription(self, description):
        self.__description = [x for x in self.__description if x not in description]
        return self.__description
    def getDescription(self, description = None):
        return self.__description
    def description_changed(self, description = None):
        return self.__description
    def isBound(self, Bound = None):
        return self.__Bound
    @property
    def jump(self):
        return self.__jump
    @jump.setter
    def jump(self, value = True):
        self.__jump = [value]
    def setJump(self, jump = True):
        self.__jump = [jump]
        return self
    def addJump(self, jump = True):
        if self.__jump == None:            self.__jump =  []
        self.__jump +=  [jump]
        return self
    def removeJump(self, jump):
        self.__jump = [x for x in self.__jump if x not in jump]
        return self.__jump
    def isJump(self, jump = True):
        return self.__jump
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def orientation(self):
        return self.__orientation
    @orientation.setter
    def orientation(self, value = [0, 0, 1, 0]):
        self.__orientation = [value]
    def setOrientation(self, orientation = [0, 0, 1, 0]):
        self.__orientation = [orientation]
        return self
    def addOrientation(self, orientation = [0, 0, 1, 0]):
        if self.__orientation == None:            self.__orientation =  []
        self.__orientation +=  [orientation]
        return self
    def removeOrientation(self, orientation):
        self.__orientation = [x for x in self.__orientation if x not in orientation]
        return self.__orientation
    def getOrientation(self, orientation = [0, 0, 1, 0]):
        return self.__orientation
    def orientation_changed(self, orientation = [0, 0, 1, 0]):
        return self.__orientation
    @property
    def retainUserOffsets(self):
        return self.__retainUserOffsets
    @retainUserOffsets.setter
    def retainUserOffsets(self, value = False):
        self.__retainUserOffsets = [value]
    def setRetainUserOffsets(self, retainUserOffsets = False):
        self.__retainUserOffsets = [retainUserOffsets]
        return self
    def addRetainUserOffsets(self, retainUserOffsets = False):
        if self.__retainUserOffsets == None:            self.__retainUserOffsets =  []
        self.__retainUserOffsets +=  [retainUserOffsets]
        return self
    def removeRetainUserOffsets(self, retainUserOffsets):
        self.__retainUserOffsets = [x for x in self.__retainUserOffsets if x not in retainUserOffsets]
        return self.__retainUserOffsets
    def isRetainUserOffsets(self, retainUserOffsets = False):
        return self.__retainUserOffsets
    @property
    def bind(self):
        return self.__bind
    @bind.setter
    def bind(self, value = None):
        self.__bind = [value]
    def set_bind(self, bind = None):
        self.__bind = [bind]
        return self
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DViewpointNode'
        if self.__bindTime is not None:
            if isinstance(self.__bindTime, six.string_types):
                str += ' bindTime="'+self.__bindTime+'"'
            else:
                str += ' bindTime="'+self.__bindTime[0]+'"'
        if self.__description is not None:
            if isinstance(self.__description, six.string_types):
                str += ' description="'+self.__description+'"'
            else:
                str += ' description="'+self.__description[0]+'"'
        if self.__Bound is not None:
            if isinstance(self.__Bound, six.string_types):
                str += ' Bound="'+self.__Bound+'"'
            else:
                str += ' Bound="'+self.__Bound[0]+'"'
        if self.__jump is not None:
            if isinstance(self.__jump, six.string_types):
                str += ' jump="'+self.__jump+'"'
            else:
                str += ' jump="'+self.__jump[0]+'"'
        if self.__orientation is not None:
            if isinstance(self.__orientation, six.string_types):
                str += ' orientation="'+self.__orientation+'"'
            else:
                str += ' orientation="'+self.__orientation[0]+'"'
        if self.__retainUserOffsets is not None:
            if isinstance(self.__retainUserOffsets, six.string_types):
                str += ' retainUserOffsets="'+self.__retainUserOffsets+'"'
            else:
                str += ' retainUserOffsets="'+self.__retainUserOffsets[0]+'"'
        if self.__bind is not None:
            if isinstance(self.__bind, six.string_types):
                str += ' bind="'+self.__bind+'"'
            else:
                str += ' bind="'+self.__bind[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DViewpointNode>'
        return str


class X3DViewportNode(X3DGroupingNode):
    def __init__(self, **kwargs):
        super(X3DViewportNode, self).__init__(**kwargs)
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        children  = kwargs.pop("children", None)
        self.__children = children
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    def addChildren(self, Children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [Children]
        return self
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DViewportNode'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '</X3DViewportNode>'
        return str


class X3DVolumeDataNode(X3DBoundedObject, X3DChildNode):
    def __init__(self, **kwargs):
        super(X3DVolumeDataNode, self).__init__(**kwargs)
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        dimensions  = kwargs.pop("dimensions", [1, 1, 1])
        if dimensions == None or len(dimensions) <= 0 or min(dimensions)  <=  0:
            return None
        self.__dimensions = dimensions
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def dimensions(self):
        return self.__dimensions
    @dimensions.setter
    def dimensions(self, value = [1, 1, 1]):
        if value == None or len(value) <= 0 or min(value)  <=  0:
            return None
        self.__dimensions = [value]
    def setDimensions(self, dimensions = [1, 1, 1]):
        if dimensions == None or len(dimensions) <= 0 or min(dimensions)  <=  0:
            return None
        self.__dimensions = [dimensions]
        return self
    def addDimensions(self, dimensions = [1, 1, 1]):
        if dimensions == None or len(dimensions) <= 0 or min(dimensions)  <=  0:
            return None
        if self.__dimensions == None:            self.__dimensions =  []
        self.__dimensions +=  [dimensions]
        return self
    def removeDimensions(self, dimensions):
        self.__dimensions = [x for x in self.__dimensions if x not in dimensions]
        return self.__dimensions
    def getDimensions(self, dimensions = [1, 1, 1]):
        return self.__dimensions
    def dimensions_changed(self, dimensions = [1, 1, 1]):
        return self.__dimensions
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DVolumeDataNode'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__dimensions is not None:
            if isinstance(self.__dimensions, six.string_types):
                str += ' dimensions="'+self.__dimensions+'"'
            else:
                str += ' dimensions="'+self.__dimensions[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</X3DVolumeDataNode>'
        return str


class X3DFogObject(object):
    def __init__(self, **kwargs):
        super(X3DFogObject, self).__init__()
        color  = kwargs.pop("color", [1, 1, 1])
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        self.__color = color
        fogType  = kwargs.pop("fogType", "LINEAR")
        if 'LINEAR' == fogType:
            pass
        elif 'EXPONENTIAL' == fogType:
            pass
        else:
            return None
        self.__fogType = fogType
        visibilityRange  = kwargs.pop("visibilityRange", 0)
        if visibilityRange == None or visibilityRange  <  0:
            return None
        self.__visibilityRange = visibilityRange
    @property
    def color(self):
        return self.__color
    @color.setter
    def color(self, value = [1, 1, 1]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__color = [value]
    def setColor(self, color = [1, 1, 1]):
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        self.__color = [color]
        return self
    def addColor(self, color = [1, 1, 1]):
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        if self.__color == None:            self.__color =  []
        self.__color +=  [color]
        return self
    def removeColor(self, color):
        self.__color = [x for x in self.__color if x not in color]
        return self.__color
    def getColor(self, color = [1, 1, 1]):
        return self.__color
    def color_changed(self, color = [1, 1, 1]):
        return self.__color
    @property
    def fogType(self):
        return self.__fogType
    @fogType.setter
    def fogType(self, value = "LINEAR"):
        if 'LINEAR' == value:
            pass
        elif 'EXPONENTIAL' == value:
            pass
        else:
            return None
        self.__fogType = [value]
    def setFogType(self, fogType = "LINEAR"):
        if 'LINEAR' == fogType:
            pass
        elif 'EXPONENTIAL' == fogType:
            pass
        else:
            return None
        self.__fogType = [fogType]
        return self
    def addFogType(self, fogType = "LINEAR"):
        if 'LINEAR' == fogType:
            pass
        elif 'EXPONENTIAL' == fogType:
            pass
        else:
            return None
        if self.__fogType == None:            self.__fogType =  []
        self.__fogType +=  [fogType]
        return self
    def removeFogType(self, fogType):
        self.__fogType = [x for x in self.__fogType if x not in fogType]
        return self.__fogType
    def getFogType(self, fogType = "LINEAR"):
        return self.__fogType
    def fogType_changed(self, fogType = "LINEAR"):
        return self.__fogType
    @property
    def visibilityRange(self):
        return self.__visibilityRange
    @visibilityRange.setter
    def visibilityRange(self, value = 0):
        if value == None or value  <  0:
            return None
        self.__visibilityRange = [value]
    def setVisibilityRange(self, visibilityRange = 0):
        if visibilityRange == None or visibilityRange  <  0:
            return None
        self.__visibilityRange = [visibilityRange]
        return self
    def addVisibilityRange(self, visibilityRange = 0):
        if visibilityRange == None or visibilityRange  <  0:
            return None
        if self.__visibilityRange == None:            self.__visibilityRange =  []
        self.__visibilityRange +=  [visibilityRange]
        return self
    def removeVisibilityRange(self, visibilityRange):
        self.__visibilityRange = [x for x in self.__visibilityRange if x not in visibilityRange]
        return self.__visibilityRange
    def getVisibilityRange(self, visibilityRange = 0):
        return self.__visibilityRange
    def visibilityRange_changed(self, visibilityRange = 0):
        return self.__visibilityRange
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DFogObject'
        if self.__color is not None:
            if isinstance(self.__color, six.string_types):
                str += ' color="'+self.__color+'"'
            else:
                str += ' color="'+self.__color[0]+'"'
        if self.__fogType is not None:
            if isinstance(self.__fogType, six.string_types):
                str += ' fogType="'+self.__fogType+'"'
            else:
                str += ' fogType="'+self.__fogType[0]+'"'
        if self.__visibilityRange is not None:
            if isinstance(self.__visibilityRange, six.string_types):
                str += ' visibilityRange="'+self.__visibilityRange+'"'
            else:
                str += ' visibilityRange="'+self.__visibilityRange[0]+'"'
        str += '>'
        str += '</X3DFogObject>'
        return str


class X3DMetadataObject(object):
    def __init__(self, **kwargs):
        super(X3DMetadataObject, self).__init__()
        name  = kwargs.pop("name", None)
        self.__name = name
        reference  = kwargs.pop("reference", None)
        self.__reference = reference
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        self.__name = [value]
    def setName(self, name = None):
        self.__name = [name]
        return self
    def addName(self, name = None):
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def reference(self):
        return self.__reference
    @reference.setter
    def reference(self, value = None):
        self.__reference = [value]
    def setReference(self, reference = None):
        self.__reference = [reference]
        return self
    def addReference(self, reference = None):
        if self.__reference == None:            self.__reference =  []
        self.__reference +=  [reference]
        return self
    def removeReference(self, reference):
        self.__reference = [x for x in self.__reference if x not in reference]
        return self.__reference
    def getReference(self, reference = None):
        return self.__reference
    def reference_changed(self, reference = None):
        return self.__reference
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DMetadataObject'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        if self.__reference is not None:
            if isinstance(self.__reference, six.string_types):
                str += ' reference="'+self.__reference+'"'
            else:
                str += ' reference="'+self.__reference[0]+'"'
        str += '>'
        str += '</X3DMetadataObject>'
        return str


class X3DPickableObject(object):
    def __init__(self, **kwargs):
        super(X3DPickableObject, self).__init__()
        pickable  = kwargs.pop("pickable", True)
        self.__pickable = pickable
    @property
    def pickable(self):
        return self.__pickable
    @pickable.setter
    def pickable(self, value = True):
        self.__pickable = [value]
    def setPickable(self, pickable = True):
        self.__pickable = [pickable]
        return self
    def addPickable(self, pickable = True):
        if self.__pickable == None:            self.__pickable =  []
        self.__pickable +=  [pickable]
        return self
    def removePickable(self, pickable):
        self.__pickable = [x for x in self.__pickable if x not in pickable]
        return self.__pickable
    def isPickable(self, pickable = True):
        return self.__pickable
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DPickableObject'
        if self.__pickable is not None:
            if isinstance(self.__pickable, six.string_types):
                str += ' pickable="'+self.__pickable+'"'
            else:
                str += ' pickable="'+self.__pickable[0]+'"'
        str += '>'
        str += '</X3DPickableObject>'
        return str


class X3DProgrammableShaderObject(object):
    def __init__(self, **kwargs):
        super(X3DProgrammableShaderObject, self).__init__()
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3DProgrammableShaderObject'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '</X3DProgrammableShaderObject>'
        return str


class Anchor(X3DUrlObject, X3DGroupingNode):
    def __init__(self, **kwargs):
        super(Anchor, self).__init__(**kwargs)
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        children  = kwargs.pop("children", None)
        self.__children = children
        description  = kwargs.pop("description", None)
        self.__description = description
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        parameter  = kwargs.pop("parameter", None)
        self.__parameter = parameter
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        url  = kwargs.pop("url", None)
        self.__url = url
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    def addChildren(self, Children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [Children]
        return self
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    @property
    def description(self):
        return self.__description
    @description.setter
    def description(self, value = None):
        self.__description = [value]
    def setDescription(self, description = None):
        self.__description = [description]
        return self
    def addDescription(self, description = None):
        if self.__description == None:            self.__description =  []
        self.__description +=  [description]
        return self
    def removeDescription(self, description):
        self.__description = [x for x in self.__description if x not in description]
        return self.__description
    def getDescription(self, description = None):
        return self.__description
    def description_changed(self, description = None):
        return self.__description
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def parameter(self):
        return self.__parameter
    @parameter.setter
    def parameter(self, value = None):
        self.__parameter = [value]
    def setParameter(self, parameter = None):
        self.__parameter = [parameter]
        return self
    def addParameter(self, parameter = None):
        if self.__parameter == None:            self.__parameter =  []
        self.__parameter +=  [parameter]
        return self
    def removeParameter(self, parameter):
        self.__parameter = [x for x in self.__parameter if x not in parameter]
        return self.__parameter
    def getParameter(self, parameter = None):
        return self.__parameter
    def parameter_changed(self, parameter = None):
        return self.__parameter
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    @property
    def url(self):
        return self.__url
    @url.setter
    def url(self, value = None):
        self.__url = [value]
    def setUrl(self, url = None):
        self.__url = [url]
        return self
    def addUrl(self, url = None):
        if self.__url == None:            self.__url =  []
        self.__url +=  [url]
        return self
    def removeUrl(self, url):
        self.__url = [x for x in self.__url if x not in url]
        return self.__url
    def getUrl(self, url = None):
        return self.__url
    def url_changed(self, url = None):
        return self.__url
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Anchor'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__description is not None:
            if isinstance(self.__description, six.string_types):
                str += ' description="'+self.__description+'"'
            else:
                str += ' description="'+self.__description[0]+'"'
        if self.__parameter is not None:
            if isinstance(self.__parameter, six.string_types):
                str += ' parameter="'+self.__parameter+'"'
            else:
                str += ' parameter="'+self.__parameter[0]+'"'
        if self.__url is not None:
            if isinstance(self.__url, six.string_types):
                str += ' url="'+self.__url+'"'
            else:
                str += ' url="'+self.__url[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '</Anchor>'
        return str


class Appearance(X3DAppearanceNode):
    def __init__(self, **kwargs):
        super(Appearance, self).__init__(**kwargs)
        fillProperties  = kwargs.pop("fillProperties", None)
        self.__fillProperties = fillProperties
        lineProperties  = kwargs.pop("lineProperties", None)
        self.__lineProperties = lineProperties
        material  = kwargs.pop("material", None)
        self.__material = material
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        pointProperties  = kwargs.pop("pointProperties", None)
        self.__pointProperties = pointProperties
        shaders  = kwargs.pop("shaders", None)
        self.__shaders = shaders
        texture  = kwargs.pop("texture", None)
        self.__texture = texture
        textureTransform  = kwargs.pop("textureTransform", None)
        self.__textureTransform = textureTransform
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def fillProperties(self):
        return self.__fillProperties
    @fillProperties.setter
    def fillProperties(self, value = None):
        self.__fillProperties = [value]
    def setFillProperties(self, fillProperties = None):
        self.__fillProperties = [fillProperties]
        return self
    def addFillProperties(self, fillProperties = None):
        if self.__fillProperties == None:            self.__fillProperties =  []
        self.__fillProperties +=  [fillProperties]
        return self
    def removeFillProperties(self, fillProperties):
        self.__fillProperties = [x for x in self.__fillProperties if x not in fillProperties]
        return self.__fillProperties
    def getFillProperties(self, fillProperties = None):
        return self.__fillProperties
    def fillProperties_changed(self, fillProperties = None):
        return self.__fillProperties
    @property
    def lineProperties(self):
        return self.__lineProperties
    @lineProperties.setter
    def lineProperties(self, value = None):
        self.__lineProperties = [value]
    def setLineProperties(self, lineProperties = None):
        self.__lineProperties = [lineProperties]
        return self
    def addLineProperties(self, lineProperties = None):
        if self.__lineProperties == None:            self.__lineProperties =  []
        self.__lineProperties +=  [lineProperties]
        return self
    def removeLineProperties(self, lineProperties):
        self.__lineProperties = [x for x in self.__lineProperties if x not in lineProperties]
        return self.__lineProperties
    def getLineProperties(self, lineProperties = None):
        return self.__lineProperties
    def lineProperties_changed(self, lineProperties = None):
        return self.__lineProperties
    @property
    def material(self):
        return self.__material
    @material.setter
    def material(self, value = None):
        self.__material = [value]
    def setMaterial(self, material = None):
        self.__material = [material]
        return self
    def addMaterial(self, material = None):
        if self.__material == None:            self.__material =  []
        self.__material +=  [material]
        return self
    def removeMaterial(self, material):
        self.__material = [x for x in self.__material if x not in material]
        return self.__material
    def getMaterial(self, material = None):
        return self.__material
    def material_changed(self, material = None):
        return self.__material
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def pointProperties(self):
        return self.__pointProperties
    @pointProperties.setter
    def pointProperties(self, value = None):
        self.__pointProperties = [value]
    def setPointProperties(self, pointProperties = None):
        self.__pointProperties = [pointProperties]
        return self
    def addPointProperties(self, pointProperties = None):
        if self.__pointProperties == None:            self.__pointProperties =  []
        self.__pointProperties +=  [pointProperties]
        return self
    def removePointProperties(self, pointProperties):
        self.__pointProperties = [x for x in self.__pointProperties if x not in pointProperties]
        return self.__pointProperties
    def getPointProperties(self, pointProperties = None):
        return self.__pointProperties
    def pointProperties_changed(self, pointProperties = None):
        return self.__pointProperties
    @property
    def shaders(self):
        return self.__shaders
    @shaders.setter
    def shaders(self, value = None):
        self.__shaders = [value]
    def setShaders(self, shaders = None):
        self.__shaders = [shaders]
        return self
    def addShaders(self, shaders = None):
        if self.__shaders == None:            self.__shaders =  []
        self.__shaders +=  [shaders]
        return self
    def removeShaders(self, shaders):
        self.__shaders = [x for x in self.__shaders if x not in shaders]
        return self.__shaders
    def getShaders(self, shaders = None):
        return self.__shaders
    def shaders_changed(self, shaders = None):
        return self.__shaders
    @property
    def texture(self):
        return self.__texture
    @texture.setter
    def texture(self, value = None):
        self.__texture = [value]
    def setTexture(self, texture = None):
        self.__texture = [texture]
        return self
    def addTexture(self, texture = None):
        if self.__texture == None:            self.__texture =  []
        self.__texture +=  [texture]
        return self
    def removeTexture(self, texture):
        self.__texture = [x for x in self.__texture if x not in texture]
        return self.__texture
    def getTexture(self, texture = None):
        return self.__texture
    def texture_changed(self, texture = None):
        return self.__texture
    @property
    def textureTransform(self):
        return self.__textureTransform
    @textureTransform.setter
    def textureTransform(self, value = None):
        self.__textureTransform = [value]
    def setTextureTransform(self, textureTransform = None):
        self.__textureTransform = [textureTransform]
        return self
    def addTextureTransform(self, textureTransform = None):
        if self.__textureTransform == None:            self.__textureTransform =  []
        self.__textureTransform +=  [textureTransform]
        return self
    def removeTextureTransform(self, textureTransform):
        self.__textureTransform = [x for x in self.__textureTransform if x not in textureTransform]
        return self.__textureTransform
    def getTextureTransform(self, textureTransform = None):
        return self.__textureTransform
    def textureTransform_changed(self, textureTransform = None):
        return self.__textureTransform
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Appearance'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<fillProperties'
        if self.__fillProperties is not None:
           for s in self.__fillProperties:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__fillProperties is not None:
           for s in self.__fillProperties:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</fillProperties>'
        str += '<lineProperties'
        if self.__lineProperties is not None:
           for s in self.__lineProperties:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__lineProperties is not None:
           for s in self.__lineProperties:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</lineProperties>'
        str += '<material'
        if self.__material is not None:
           for s in self.__material:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__material is not None:
           for s in self.__material:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</material>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<pointProperties'
        if self.__pointProperties is not None:
           for s in self.__pointProperties:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__pointProperties is not None:
           for s in self.__pointProperties:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</pointProperties>'
        str += '<shaders'
        if self.__shaders is not None:
           for s in self.__shaders:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__shaders is not None:
           for s in self.__shaders:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</shaders>'
        str += '<texture'
        if self.__texture is not None:
           for s in self.__texture:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__texture is not None:
           for s in self.__texture:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</texture>'
        str += '<textureTransform'
        if self.__textureTransform is not None:
           for s in self.__textureTransform:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__textureTransform is not None:
           for s in self.__textureTransform:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</textureTransform>'
        str += '</Appearance>'
        return str


class Arc2D(X3DGeometryNode):
    def __init__(self, **kwargs):
        super(Arc2D, self).__init__(**kwargs)
        endAngle  = kwargs.pop("endAngle", 1.570796)
        if endAngle == None or endAngle  <=  -6.2832:
            return None
        if endAngle == None or endAngle  >=  6.2832:
            return None
        self.__endAngle = endAngle
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        radius  = kwargs.pop("radius", 1)
        if radius == None or radius  <=  0:
            return None
        self.__radius = radius
        startAngle  = kwargs.pop("startAngle", 0)
        if startAngle == None or startAngle  <=  -6.2832:
            return None
        if startAngle == None or startAngle  >=  6.2832:
            return None
        self.__startAngle = startAngle
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Arc2D'
        if self.__endAngle is not None:
            if isinstance(self.__endAngle, six.string_types):
                str += ' endAngle="'+self.__endAngle+'"'
            else:
                str += ' endAngle="'+self.__endAngle[0]+'"'
        if self.__radius is not None:
            if isinstance(self.__radius, six.string_types):
                str += ' radius="'+self.__radius+'"'
            else:
                str += ' radius="'+self.__radius[0]+'"'
        if self.__startAngle is not None:
            if isinstance(self.__startAngle, six.string_types):
                str += ' startAngle="'+self.__startAngle+'"'
            else:
                str += ' startAngle="'+self.__startAngle[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</Arc2D>'
        return str


class ArcClose2D(X3DGeometryNode):
    def __init__(self, **kwargs):
        super(ArcClose2D, self).__init__(**kwargs)
        closureType  = kwargs.pop("closureType", "PIE")
        if 'PIE' == closureType:
            pass
        elif 'CHORD' == closureType:
            pass
        else:
            return None
        self.__closureType = closureType
        endAngle  = kwargs.pop("endAngle", 1.570796)
        if endAngle == None or endAngle  <=  -6.2832:
            return None
        if endAngle == None or endAngle  >=  6.2832:
            return None
        self.__endAngle = endAngle
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        radius  = kwargs.pop("radius", 1)
        if radius == None or radius  <=  0:
            return None
        self.__radius = radius
        solid  = kwargs.pop("solid", False)
        self.__solid = solid
        startAngle  = kwargs.pop("startAngle", 0)
        if startAngle == None or startAngle  <=  -6.2832:
            return None
        if startAngle == None or startAngle  >=  6.2832:
            return None
        self.__startAngle = startAngle
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ArcClose2D'
        if self.__closureType is not None:
            if isinstance(self.__closureType, six.string_types):
                str += ' closureType="'+self.__closureType+'"'
            else:
                str += ' closureType="'+self.__closureType[0]+'"'
        if self.__endAngle is not None:
            if isinstance(self.__endAngle, six.string_types):
                str += ' endAngle="'+self.__endAngle+'"'
            else:
                str += ' endAngle="'+self.__endAngle[0]+'"'
        if self.__radius is not None:
            if isinstance(self.__radius, six.string_types):
                str += ' radius="'+self.__radius+'"'
            else:
                str += ' radius="'+self.__radius[0]+'"'
        if self.__solid is not None:
            if isinstance(self.__solid, six.string_types):
                str += ' solid="'+self.__solid+'"'
            else:
                str += ' solid="'+self.__solid[0]+'"'
        if self.__startAngle is not None:
            if isinstance(self.__startAngle, six.string_types):
                str += ' startAngle="'+self.__startAngle+'"'
            else:
                str += ' startAngle="'+self.__startAngle[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</ArcClose2D>'
        return str


class AudioClip(X3DUrlObject, X3DSoundSourceNode):
    def __init__(self, **kwargs):
        super(AudioClip, self).__init__(**kwargs)
        description  = kwargs.pop("description", None)
        self.__description = description
        duration_changed  = kwargs.pop("duration_changed", None)
        if duration_changed == None or duration_changed  <  -1:
            return None
        self.__duration_changed = duration_changed
        elapsedTime  = kwargs.pop("elapsedTime", None)
        if elapsedTime == None or elapsedTime  <  0:
            return None
        self.__elapsedTime = elapsedTime
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        Paused  = kwargs.pop("Paused", None)
        self.__Paused = Paused
        loop  = kwargs.pop("loop", False)
        self.__loop = loop
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        pauseTime  = kwargs.pop("pauseTime", 0)
        self.__pauseTime = pauseTime
        pitch  = kwargs.pop("pitch", 1.0)
        if pitch == None or pitch  <=  0:
            return None
        self.__pitch = pitch
        resumeTime  = kwargs.pop("resumeTime", 0)
        self.__resumeTime = resumeTime
        startTime  = kwargs.pop("startTime", 0)
        self.__startTime = startTime
        stopTime  = kwargs.pop("stopTime", 0)
        self.__stopTime = stopTime
        url  = kwargs.pop("url", None)
        self.__url = url
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def description(self):
        return self.__description
    @description.setter
    def description(self, value = None):
        self.__description = [value]
    def setDescription(self, description = None):
        self.__description = [description]
        return self
    def addDescription(self, description = None):
        if self.__description == None:            self.__description =  []
        self.__description +=  [description]
        return self
    def removeDescription(self, description):
        self.__description = [x for x in self.__description if x not in description]
        return self.__description
    def getDescription(self, description = None):
        return self.__description
    def description_changed(self, description = None):
        return self.__description
    def removeduration_changed(self, duration_changed):
        self.__duration_changed = [x for x in self.__duration_changed if x not in duration_changed]
        return self.__duration_changed
    def getduration_changed(self, duration_changed = None):
        return self.__duration_changed
    def duration_changed_changed(self, duration_changed = None):
        return self.__duration_changed
    def removeElapsedTime(self, elapsedTime):
        self.__elapsedTime = [x for x in self.__elapsedTime if x not in elapsedTime]
        return self.__elapsedTime
    def getElapsedTime(self, elapsedTime = None):
        return self.__elapsedTime
    def elapsedTime_changed(self, elapsedTime = None):
        return self.__elapsedTime
    def isActive(self, Active = None):
        return self.__Active
    def isPaused(self, Paused = None):
        return self.__Paused
    @property
    def loop(self):
        return self.__loop
    @loop.setter
    def loop(self, value = False):
        self.__loop = [value]
    def setLoop(self, loop = False):
        self.__loop = [loop]
        return self
    def addLoop(self, loop = False):
        if self.__loop == None:            self.__loop =  []
        self.__loop +=  [loop]
        return self
    def removeLoop(self, loop):
        self.__loop = [x for x in self.__loop if x not in loop]
        return self.__loop
    def isLoop(self, loop = False):
        return self.__loop
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def pauseTime(self):
        return self.__pauseTime
    @pauseTime.setter
    def pauseTime(self, value = 0):
        self.__pauseTime = [value]
    def setPauseTime(self, pauseTime = 0):
        self.__pauseTime = [pauseTime]
        return self
    def addPauseTime(self, pauseTime = 0):
        if self.__pauseTime == None:            self.__pauseTime =  []
        self.__pauseTime +=  [pauseTime]
        return self
    def removePauseTime(self, pauseTime):
        self.__pauseTime = [x for x in self.__pauseTime if x not in pauseTime]
        return self.__pauseTime
    def getPauseTime(self, pauseTime = 0):
        return self.__pauseTime
    def pauseTime_changed(self, pauseTime = 0):
        return self.__pauseTime
    @property
    def pitch(self):
        return self.__pitch
    @pitch.setter
    def pitch(self, value = 1.0):
        if value == None or value  <=  0:
            return None
        self.__pitch = [value]
    def setPitch(self, pitch = 1.0):
        if pitch == None or pitch  <=  0:
            return None
        self.__pitch = [pitch]
        return self
    def addPitch(self, pitch = 1.0):
        if pitch == None or pitch  <=  0:
            return None
        if self.__pitch == None:            self.__pitch =  []
        self.__pitch +=  [pitch]
        return self
    def removePitch(self, pitch):
        self.__pitch = [x for x in self.__pitch if x not in pitch]
        return self.__pitch
    def getPitch(self, pitch = 1.0):
        return self.__pitch
    def pitch_changed(self, pitch = 1.0):
        return self.__pitch
    @property
    def resumeTime(self):
        return self.__resumeTime
    @resumeTime.setter
    def resumeTime(self, value = 0):
        self.__resumeTime = [value]
    def setResumeTime(self, resumeTime = 0):
        self.__resumeTime = [resumeTime]
        return self
    def addResumeTime(self, resumeTime = 0):
        if self.__resumeTime == None:            self.__resumeTime =  []
        self.__resumeTime +=  [resumeTime]
        return self
    def removeResumeTime(self, resumeTime):
        self.__resumeTime = [x for x in self.__resumeTime if x not in resumeTime]
        return self.__resumeTime
    def getResumeTime(self, resumeTime = 0):
        return self.__resumeTime
    def resumeTime_changed(self, resumeTime = 0):
        return self.__resumeTime
    @property
    def startTime(self):
        return self.__startTime
    @startTime.setter
    def startTime(self, value = 0):
        self.__startTime = [value]
    def setStartTime(self, startTime = 0):
        self.__startTime = [startTime]
        return self
    def addStartTime(self, startTime = 0):
        if self.__startTime == None:            self.__startTime =  []
        self.__startTime +=  [startTime]
        return self
    def removeStartTime(self, startTime):
        self.__startTime = [x for x in self.__startTime if x not in startTime]
        return self.__startTime
    def getStartTime(self, startTime = 0):
        return self.__startTime
    def startTime_changed(self, startTime = 0):
        return self.__startTime
    @property
    def stopTime(self):
        return self.__stopTime
    @stopTime.setter
    def stopTime(self, value = 0):
        self.__stopTime = [value]
    def setStopTime(self, stopTime = 0):
        self.__stopTime = [stopTime]
        return self
    def addStopTime(self, stopTime = 0):
        if self.__stopTime == None:            self.__stopTime =  []
        self.__stopTime +=  [stopTime]
        return self
    def removeStopTime(self, stopTime):
        self.__stopTime = [x for x in self.__stopTime if x not in stopTime]
        return self.__stopTime
    def getStopTime(self, stopTime = 0):
        return self.__stopTime
    def stopTime_changed(self, stopTime = 0):
        return self.__stopTime
    @property
    def url(self):
        return self.__url
    @url.setter
    def url(self, value = None):
        self.__url = [value]
    def setUrl(self, url = None):
        self.__url = [url]
        return self
    def addUrl(self, url = None):
        if self.__url == None:            self.__url =  []
        self.__url +=  [url]
        return self
    def removeUrl(self, url):
        self.__url = [x for x in self.__url if x not in url]
        return self.__url
    def getUrl(self, url = None):
        return self.__url
    def url_changed(self, url = None):
        return self.__url
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<AudioClip'
        if self.__description is not None:
            if isinstance(self.__description, six.string_types):
                str += ' description="'+self.__description+'"'
            else:
                str += ' description="'+self.__description[0]+'"'
        if self.__duration_changed is not None:
            if isinstance(self.__duration_changed, six.string_types):
                str += ' duration_changed="'+self.__duration_changed+'"'
            else:
                str += ' duration_changed="'+self.__duration_changed[0]+'"'
        if self.__elapsedTime is not None:
            if isinstance(self.__elapsedTime, six.string_types):
                str += ' elapsedTime="'+self.__elapsedTime+'"'
            else:
                str += ' elapsedTime="'+self.__elapsedTime[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__Paused is not None:
            if isinstance(self.__Paused, six.string_types):
                str += ' Paused="'+self.__Paused+'"'
            else:
                str += ' Paused="'+self.__Paused[0]+'"'
        if self.__loop is not None:
            if isinstance(self.__loop, six.string_types):
                str += ' loop="'+self.__loop+'"'
            else:
                str += ' loop="'+self.__loop[0]+'"'
        if self.__pauseTime is not None:
            if isinstance(self.__pauseTime, six.string_types):
                str += ' pauseTime="'+self.__pauseTime+'"'
            else:
                str += ' pauseTime="'+self.__pauseTime[0]+'"'
        if self.__pitch is not None:
            if isinstance(self.__pitch, six.string_types):
                str += ' pitch="'+self.__pitch+'"'
            else:
                str += ' pitch="'+self.__pitch[0]+'"'
        if self.__resumeTime is not None:
            if isinstance(self.__resumeTime, six.string_types):
                str += ' resumeTime="'+self.__resumeTime+'"'
            else:
                str += ' resumeTime="'+self.__resumeTime[0]+'"'
        if self.__startTime is not None:
            if isinstance(self.__startTime, six.string_types):
                str += ' startTime="'+self.__startTime+'"'
            else:
                str += ' startTime="'+self.__startTime[0]+'"'
        if self.__stopTime is not None:
            if isinstance(self.__stopTime, six.string_types):
                str += ' stopTime="'+self.__stopTime+'"'
            else:
                str += ' stopTime="'+self.__stopTime[0]+'"'
        if self.__url is not None:
            if isinstance(self.__url, six.string_types):
                str += ' url="'+self.__url+'"'
            else:
                str += ' url="'+self.__url[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</AudioClip>'
        return str


class Background(X3DBackgroundNode):
    def __init__(self, **kwargs):
        super(Background, self).__init__(**kwargs)
        backUrl  = kwargs.pop("backUrl", None)
        self.__backUrl = backUrl
        bindTime  = kwargs.pop("bindTime", None)
        self.__bindTime = bindTime
        bottomUrl  = kwargs.pop("bottomUrl", None)
        self.__bottomUrl = bottomUrl
        frontUrl  = kwargs.pop("frontUrl", None)
        self.__frontUrl = frontUrl
        groundAngle  = kwargs.pop("groundAngle", None)
        if groundAngle == None or len(groundAngle) <= 0 or min(groundAngle)  <  0:
            return None
        if groundAngle == None or len(groundAngle) <= 0 or max(groundAngle)  >  1.5708:
            return None
        self.__groundAngle = groundAngle
        groundColor  = kwargs.pop("groundColor", None)
        if groundColor == None or len(groundColor) <= 0 or min(groundColor)  <  0:
            return None
        if groundColor == None or len(groundColor) <= 0 or max(groundColor)  >  1:
            return None
        self.__groundColor = groundColor
        Bound  = kwargs.pop("Bound", None)
        self.__Bound = Bound
        leftUrl  = kwargs.pop("leftUrl", None)
        self.__leftUrl = leftUrl
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        rightUrl  = kwargs.pop("rightUrl", None)
        self.__rightUrl = rightUrl
        bind  = kwargs.pop("bind", None)
        self.__bind = bind
        skyAngle  = kwargs.pop("skyAngle", None)
        if skyAngle == None or len(skyAngle) <= 0 or min(skyAngle)  <  0:
            return None
        if skyAngle == None or len(skyAngle) <= 0 or max(skyAngle)  >  3.1416:
            return None
        self.__skyAngle = skyAngle
        skyColor  = kwargs.pop("skyColor", [0, 0, 0])
        if skyColor == None or len(skyColor) <= 0 or min(skyColor)  <  0:
            return None
        if skyColor == None or len(skyColor) <= 0 or max(skyColor)  >  1:
            return None
        self.__skyColor = skyColor
        topUrl  = kwargs.pop("topUrl", None)
        self.__topUrl = topUrl
        transparency  = kwargs.pop("transparency", 0)
        if transparency == None or transparency  <  0:
            return None
        if transparency == None or transparency  >  1:
            return None
        self.__transparency = transparency
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def backUrl(self):
        return self.__backUrl
    @backUrl.setter
    def backUrl(self, value = None):
        self.__backUrl = [value]
    def setBackUrl(self, backUrl = None):
        self.__backUrl = [backUrl]
        return self
    def addBackUrl(self, backUrl = None):
        if self.__backUrl == None:            self.__backUrl =  []
        self.__backUrl +=  [backUrl]
        return self
    def removeBackUrl(self, backUrl):
        self.__backUrl = [x for x in self.__backUrl if x not in backUrl]
        return self.__backUrl
    def getBackUrl(self, backUrl = None):
        return self.__backUrl
    def backUrl_changed(self, backUrl = None):
        return self.__backUrl
    def removeBindTime(self, bindTime):
        self.__bindTime = [x for x in self.__bindTime if x not in bindTime]
        return self.__bindTime
    def getBindTime(self, bindTime = None):
        return self.__bindTime
    def bindTime_changed(self, bindTime = None):
        return self.__bindTime
    @property
    def bottomUrl(self):
        return self.__bottomUrl
    @bottomUrl.setter
    def bottomUrl(self, value = None):
        self.__bottomUrl = [value]
    def setBottomUrl(self, bottomUrl = None):
        self.__bottomUrl = [bottomUrl]
        return self
    def addBottomUrl(self, bottomUrl = None):
        if self.__bottomUrl == None:            self.__bottomUrl =  []
        self.__bottomUrl +=  [bottomUrl]
        return self
    def removeBottomUrl(self, bottomUrl):
        self.__bottomUrl = [x for x in self.__bottomUrl if x not in bottomUrl]
        return self.__bottomUrl
    def getBottomUrl(self, bottomUrl = None):
        return self.__bottomUrl
    def bottomUrl_changed(self, bottomUrl = None):
        return self.__bottomUrl
    @property
    def frontUrl(self):
        return self.__frontUrl
    @frontUrl.setter
    def frontUrl(self, value = None):
        self.__frontUrl = [value]
    def setFrontUrl(self, frontUrl = None):
        self.__frontUrl = [frontUrl]
        return self
    def addFrontUrl(self, frontUrl = None):
        if self.__frontUrl == None:            self.__frontUrl =  []
        self.__frontUrl +=  [frontUrl]
        return self
    def removeFrontUrl(self, frontUrl):
        self.__frontUrl = [x for x in self.__frontUrl if x not in frontUrl]
        return self.__frontUrl
    def getFrontUrl(self, frontUrl = None):
        return self.__frontUrl
    def frontUrl_changed(self, frontUrl = None):
        return self.__frontUrl
    @property
    def groundAngle(self):
        return self.__groundAngle
    @groundAngle.setter
    def groundAngle(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1.5708:
            return None
        self.__groundAngle = [value]
    def setGroundAngle(self, groundAngle = None):
        if groundAngle == None or len(groundAngle) <= 0 or min(groundAngle)  <  0:
            return None
        if groundAngle == None or len(groundAngle) <= 0 or max(groundAngle)  >  1.5708:
            return None
        self.__groundAngle = [groundAngle]
        return self
    def addGroundAngle(self, groundAngle = None):
        if groundAngle == None or len(groundAngle) <= 0 or min(groundAngle)  <  0:
            return None
        if groundAngle == None or len(groundAngle) <= 0 or max(groundAngle)  >  1.5708:
            return None
        if self.__groundAngle == None:            self.__groundAngle =  []
        self.__groundAngle +=  [groundAngle]
        return self
    def removeGroundAngle(self, groundAngle):
        self.__groundAngle = [x for x in self.__groundAngle if x not in groundAngle]
        return self.__groundAngle
    def getGroundAngle(self, groundAngle = None):
        return self.__groundAngle
    def groundAngle_changed(self, groundAngle = None):
        return self.__groundAngle
    @property
    def groundColor(self):
        return self.__groundColor
    @groundColor.setter
    def groundColor(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__groundColor = [value]
    def setGroundColor(self, groundColor = None):
        if groundColor == None or len(groundColor) <= 0 or min(groundColor)  <  0:
            return None
        if groundColor == None or len(groundColor) <= 0 or max(groundColor)  >  1:
            return None
        self.__groundColor = [groundColor]
        return self
    def addGroundColor(self, groundColor = None):
        if groundColor == None or len(groundColor) <= 0 or min(groundColor)  <  0:
            return None
        if groundColor == None or len(groundColor) <= 0 or max(groundColor)  >  1:
            return None
        if self.__groundColor == None:            self.__groundColor =  []
        self.__groundColor +=  [groundColor]
        return self
    def removeGroundColor(self, groundColor):
        self.__groundColor = [x for x in self.__groundColor if x not in groundColor]
        return self.__groundColor
    def getGroundColor(self, groundColor = None):
        return self.__groundColor
    def groundColor_changed(self, groundColor = None):
        return self.__groundColor
    def isBound(self, Bound = None):
        return self.__Bound
    @property
    def leftUrl(self):
        return self.__leftUrl
    @leftUrl.setter
    def leftUrl(self, value = None):
        self.__leftUrl = [value]
    def setLeftUrl(self, leftUrl = None):
        self.__leftUrl = [leftUrl]
        return self
    def addLeftUrl(self, leftUrl = None):
        if self.__leftUrl == None:            self.__leftUrl =  []
        self.__leftUrl +=  [leftUrl]
        return self
    def removeLeftUrl(self, leftUrl):
        self.__leftUrl = [x for x in self.__leftUrl if x not in leftUrl]
        return self.__leftUrl
    def getLeftUrl(self, leftUrl = None):
        return self.__leftUrl
    def leftUrl_changed(self, leftUrl = None):
        return self.__leftUrl
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def rightUrl(self):
        return self.__rightUrl
    @rightUrl.setter
    def rightUrl(self, value = None):
        self.__rightUrl = [value]
    def setRightUrl(self, rightUrl = None):
        self.__rightUrl = [rightUrl]
        return self
    def addRightUrl(self, rightUrl = None):
        if self.__rightUrl == None:            self.__rightUrl =  []
        self.__rightUrl +=  [rightUrl]
        return self
    def removeRightUrl(self, rightUrl):
        self.__rightUrl = [x for x in self.__rightUrl if x not in rightUrl]
        return self.__rightUrl
    def getRightUrl(self, rightUrl = None):
        return self.__rightUrl
    def rightUrl_changed(self, rightUrl = None):
        return self.__rightUrl
    @property
    def bind(self):
        return self.__bind
    @bind.setter
    def bind(self, value = None):
        self.__bind = [value]
    def set_bind(self, bind = None):
        self.__bind = [bind]
        return self
    @property
    def skyAngle(self):
        return self.__skyAngle
    @skyAngle.setter
    def skyAngle(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  3.1416:
            return None
        self.__skyAngle = [value]
    def setSkyAngle(self, skyAngle = None):
        if skyAngle == None or len(skyAngle) <= 0 or min(skyAngle)  <  0:
            return None
        if skyAngle == None or len(skyAngle) <= 0 or max(skyAngle)  >  3.1416:
            return None
        self.__skyAngle = [skyAngle]
        return self
    def addSkyAngle(self, skyAngle = None):
        if skyAngle == None or len(skyAngle) <= 0 or min(skyAngle)  <  0:
            return None
        if skyAngle == None or len(skyAngle) <= 0 or max(skyAngle)  >  3.1416:
            return None
        if self.__skyAngle == None:            self.__skyAngle =  []
        self.__skyAngle +=  [skyAngle]
        return self
    def removeSkyAngle(self, skyAngle):
        self.__skyAngle = [x for x in self.__skyAngle if x not in skyAngle]
        return self.__skyAngle
    def getSkyAngle(self, skyAngle = None):
        return self.__skyAngle
    def skyAngle_changed(self, skyAngle = None):
        return self.__skyAngle
    @property
    def skyColor(self):
        return self.__skyColor
    @skyColor.setter
    def skyColor(self, value = [0, 0, 0]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__skyColor = [value]
    def setSkyColor(self, skyColor = [0, 0, 0]):
        if skyColor == None or len(skyColor) <= 0 or min(skyColor)  <  0:
            return None
        if skyColor == None or len(skyColor) <= 0 or max(skyColor)  >  1:
            return None
        self.__skyColor = [skyColor]
        return self
    def addSkyColor(self, skyColor = [0, 0, 0]):
        if skyColor == None or len(skyColor) <= 0 or min(skyColor)  <  0:
            return None
        if skyColor == None or len(skyColor) <= 0 or max(skyColor)  >  1:
            return None
        if self.__skyColor == None:            self.__skyColor =  []
        self.__skyColor +=  [skyColor]
        return self
    def removeSkyColor(self, skyColor):
        self.__skyColor = [x for x in self.__skyColor if x not in skyColor]
        return self.__skyColor
    def getSkyColor(self, skyColor = [0, 0, 0]):
        return self.__skyColor
    def skyColor_changed(self, skyColor = [0, 0, 0]):
        return self.__skyColor
    @property
    def topUrl(self):
        return self.__topUrl
    @topUrl.setter
    def topUrl(self, value = None):
        self.__topUrl = [value]
    def setTopUrl(self, topUrl = None):
        self.__topUrl = [topUrl]
        return self
    def addTopUrl(self, topUrl = None):
        if self.__topUrl == None:            self.__topUrl =  []
        self.__topUrl +=  [topUrl]
        return self
    def removeTopUrl(self, topUrl):
        self.__topUrl = [x for x in self.__topUrl if x not in topUrl]
        return self.__topUrl
    def getTopUrl(self, topUrl = None):
        return self.__topUrl
    def topUrl_changed(self, topUrl = None):
        return self.__topUrl
    @property
    def transparency(self):
        return self.__transparency
    @transparency.setter
    def transparency(self, value = 0):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__transparency = [value]
    def setTransparency(self, transparency = 0):
        if transparency == None or transparency  <  0:
            return None
        if transparency == None or transparency  >  1:
            return None
        self.__transparency = [transparency]
        return self
    def addTransparency(self, transparency = 0):
        if transparency == None or transparency  <  0:
            return None
        if transparency == None or transparency  >  1:
            return None
        if self.__transparency == None:            self.__transparency =  []
        self.__transparency +=  [transparency]
        return self
    def removeTransparency(self, transparency):
        self.__transparency = [x for x in self.__transparency if x not in transparency]
        return self.__transparency
    def getTransparency(self, transparency = 0):
        return self.__transparency
    def transparency_changed(self, transparency = 0):
        return self.__transparency
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Background'
        if self.__backUrl is not None:
            if isinstance(self.__backUrl, six.string_types):
                str += ' backUrl="'+self.__backUrl+'"'
            else:
                str += ' backUrl="'+self.__backUrl[0]+'"'
        if self.__bindTime is not None:
            if isinstance(self.__bindTime, six.string_types):
                str += ' bindTime="'+self.__bindTime+'"'
            else:
                str += ' bindTime="'+self.__bindTime[0]+'"'
        if self.__bottomUrl is not None:
            if isinstance(self.__bottomUrl, six.string_types):
                str += ' bottomUrl="'+self.__bottomUrl+'"'
            else:
                str += ' bottomUrl="'+self.__bottomUrl[0]+'"'
        if self.__frontUrl is not None:
            if isinstance(self.__frontUrl, six.string_types):
                str += ' frontUrl="'+self.__frontUrl+'"'
            else:
                str += ' frontUrl="'+self.__frontUrl[0]+'"'
        if self.__groundAngle is not None:
            if isinstance(self.__groundAngle, six.string_types):
                str += ' groundAngle="'+self.__groundAngle+'"'
            else:
                str += ' groundAngle="'+self.__groundAngle[0]+'"'
        if self.__groundColor is not None:
            if isinstance(self.__groundColor, six.string_types):
                str += ' groundColor="'+self.__groundColor+'"'
            else:
                str += ' groundColor="'+self.__groundColor[0]+'"'
        if self.__Bound is not None:
            if isinstance(self.__Bound, six.string_types):
                str += ' Bound="'+self.__Bound+'"'
            else:
                str += ' Bound="'+self.__Bound[0]+'"'
        if self.__leftUrl is not None:
            if isinstance(self.__leftUrl, six.string_types):
                str += ' leftUrl="'+self.__leftUrl+'"'
            else:
                str += ' leftUrl="'+self.__leftUrl[0]+'"'
        if self.__rightUrl is not None:
            if isinstance(self.__rightUrl, six.string_types):
                str += ' rightUrl="'+self.__rightUrl+'"'
            else:
                str += ' rightUrl="'+self.__rightUrl[0]+'"'
        if self.__bind is not None:
            if isinstance(self.__bind, six.string_types):
                str += ' bind="'+self.__bind+'"'
            else:
                str += ' bind="'+self.__bind[0]+'"'
        if self.__skyAngle is not None:
            if isinstance(self.__skyAngle, six.string_types):
                str += ' skyAngle="'+self.__skyAngle+'"'
            else:
                str += ' skyAngle="'+self.__skyAngle[0]+'"'
        if self.__skyColor is not None:
            if isinstance(self.__skyColor, six.string_types):
                str += ' skyColor="'+self.__skyColor+'"'
            else:
                str += ' skyColor="'+self.__skyColor[0]+'"'
        if self.__topUrl is not None:
            if isinstance(self.__topUrl, six.string_types):
                str += ' topUrl="'+self.__topUrl+'"'
            else:
                str += ' topUrl="'+self.__topUrl[0]+'"'
        if self.__transparency is not None:
            if isinstance(self.__transparency, six.string_types):
                str += ' transparency="'+self.__transparency+'"'
            else:
                str += ' transparency="'+self.__transparency[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</Background>'
        return str


class BallJoint(X3DRigidJointNode):
    def __init__(self, **kwargs):
        super(BallJoint, self).__init__(**kwargs)
        anchorPoint  = kwargs.pop("anchorPoint", [0, 0, 0])
        self.__anchorPoint = anchorPoint
        body1  = kwargs.pop("body1", None)
        self.__body1 = body1
        body1AnchorPoint  = kwargs.pop("body1AnchorPoint", None)
        self.__body1AnchorPoint = body1AnchorPoint
        body2  = kwargs.pop("body2", None)
        self.__body2 = body2
        body2AnchorPoint  = kwargs.pop("body2AnchorPoint", None)
        self.__body2AnchorPoint = body2AnchorPoint
        forceOutput  = kwargs.pop("forceOutput", ["NONE"])
        self.__forceOutput = forceOutput
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def anchorPoint(self):
        return self.__anchorPoint
    @anchorPoint.setter
    def anchorPoint(self, value = [0, 0, 0]):
        self.__anchorPoint = [value]
    def setAnchorPoint(self, anchorPoint = [0, 0, 0]):
        self.__anchorPoint = [anchorPoint]
        return self
    def addAnchorPoint(self, anchorPoint = [0, 0, 0]):
        if self.__anchorPoint == None:            self.__anchorPoint =  []
        self.__anchorPoint +=  [anchorPoint]
        return self
    def removeAnchorPoint(self, anchorPoint):
        self.__anchorPoint = [x for x in self.__anchorPoint if x not in anchorPoint]
        return self.__anchorPoint
    def getAnchorPoint(self, anchorPoint = [0, 0, 0]):
        return self.__anchorPoint
    def anchorPoint_changed(self, anchorPoint = [0, 0, 0]):
        return self.__anchorPoint
    @property
    def body1(self):
        return self.__body1
    @body1.setter
    def body1(self, value = None):
        self.__body1 = [value]
    def setBody1(self, body1 = None):
        self.__body1 = [body1]
        return self
    def addBody1(self, body1 = None):
        if self.__body1 == None:            self.__body1 =  []
        self.__body1 +=  [body1]
        return self
    def removeBody1(self, body1):
        self.__body1 = [x for x in self.__body1 if x not in body1]
        return self.__body1
    def getBody1(self, body1 = None):
        return self.__body1
    def body1_changed(self, body1 = None):
        return self.__body1
    def removeBody1AnchorPoint(self, body1AnchorPoint):
        self.__body1AnchorPoint = [x for x in self.__body1AnchorPoint if x not in body1AnchorPoint]
        return self.__body1AnchorPoint
    def getBody1AnchorPoint(self, body1AnchorPoint = None):
        return self.__body1AnchorPoint
    def body1AnchorPoint_changed(self, body1AnchorPoint = None):
        return self.__body1AnchorPoint
    @property
    def body2(self):
        return self.__body2
    @body2.setter
    def body2(self, value = None):
        self.__body2 = [value]
    def setBody2(self, body2 = None):
        self.__body2 = [body2]
        return self
    def addBody2(self, body2 = None):
        if self.__body2 == None:            self.__body2 =  []
        self.__body2 +=  [body2]
        return self
    def removeBody2(self, body2):
        self.__body2 = [x for x in self.__body2 if x not in body2]
        return self.__body2
    def getBody2(self, body2 = None):
        return self.__body2
    def body2_changed(self, body2 = None):
        return self.__body2
    def removeBody2AnchorPoint(self, body2AnchorPoint):
        self.__body2AnchorPoint = [x for x in self.__body2AnchorPoint if x not in body2AnchorPoint]
        return self.__body2AnchorPoint
    def getBody2AnchorPoint(self, body2AnchorPoint = None):
        return self.__body2AnchorPoint
    def body2AnchorPoint_changed(self, body2AnchorPoint = None):
        return self.__body2AnchorPoint
    @property
    def forceOutput(self):
        return self.__forceOutput
    @forceOutput.setter
    def forceOutput(self, value = ["NONE"]):
        self.__forceOutput = [value]
    def setForceOutput(self, forceOutput = ["NONE"]):
        self.__forceOutput = [forceOutput]
        return self
    def addForceOutput(self, forceOutput = ["NONE"]):
        if self.__forceOutput == None:            self.__forceOutput =  []
        self.__forceOutput +=  [forceOutput]
        return self
    def removeForceOutput(self, forceOutput):
        self.__forceOutput = [x for x in self.__forceOutput if x not in forceOutput]
        return self.__forceOutput
    def getForceOutput(self, forceOutput = ["NONE"]):
        return self.__forceOutput
    def forceOutput_changed(self, forceOutput = ["NONE"]):
        return self.__forceOutput
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<BallJoint'
        if self.__anchorPoint is not None:
            if isinstance(self.__anchorPoint, six.string_types):
                str += ' anchorPoint="'+self.__anchorPoint+'"'
            else:
                str += ' anchorPoint="'+self.__anchorPoint[0]+'"'
        if self.__body1AnchorPoint is not None:
            if isinstance(self.__body1AnchorPoint, six.string_types):
                str += ' body1AnchorPoint="'+self.__body1AnchorPoint+'"'
            else:
                str += ' body1AnchorPoint="'+self.__body1AnchorPoint[0]+'"'
        if self.__body2AnchorPoint is not None:
            if isinstance(self.__body2AnchorPoint, six.string_types):
                str += ' body2AnchorPoint="'+self.__body2AnchorPoint+'"'
            else:
                str += ' body2AnchorPoint="'+self.__body2AnchorPoint[0]+'"'
        if self.__forceOutput is not None:
            if isinstance(self.__forceOutput, six.string_types):
                str += ' forceOutput="'+self.__forceOutput+'"'
            else:
                str += ' forceOutput="'+self.__forceOutput[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<body1'
        if self.__body1 is not None:
           for s in self.__body1:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__body1 is not None:
           for s in self.__body1:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</body1>'
        str += '<body2'
        if self.__body2 is not None:
           for s in self.__body2:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__body2 is not None:
           for s in self.__body2:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</body2>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</BallJoint>'
        return str


class Billboard(X3DGroupingNode):
    def __init__(self, **kwargs):
        super(Billboard, self).__init__(**kwargs)
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        axisOfRotation  = kwargs.pop("axisOfRotation", [0, 1, 0])
        self.__axisOfRotation = axisOfRotation
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        children  = kwargs.pop("children", None)
        self.__children = children
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    def addChildren(self, Children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [Children]
        return self
    @property
    def axisOfRotation(self):
        return self.__axisOfRotation
    @axisOfRotation.setter
    def axisOfRotation(self, value = [0, 1, 0]):
        self.__axisOfRotation = [value]
    def setAxisOfRotation(self, axisOfRotation = [0, 1, 0]):
        self.__axisOfRotation = [axisOfRotation]
        return self
    def addAxisOfRotation(self, axisOfRotation = [0, 1, 0]):
        if self.__axisOfRotation == None:            self.__axisOfRotation =  []
        self.__axisOfRotation +=  [axisOfRotation]
        return self
    def removeAxisOfRotation(self, axisOfRotation):
        self.__axisOfRotation = [x for x in self.__axisOfRotation if x not in axisOfRotation]
        return self.__axisOfRotation
    def getAxisOfRotation(self, axisOfRotation = [0, 1, 0]):
        return self.__axisOfRotation
    def axisOfRotation_changed(self, axisOfRotation = [0, 1, 0]):
        return self.__axisOfRotation
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Billboard'
        if self.__axisOfRotation is not None:
            if isinstance(self.__axisOfRotation, six.string_types):
                str += ' axisOfRotation="'+self.__axisOfRotation+'"'
            else:
                str += ' axisOfRotation="'+self.__axisOfRotation[0]+'"'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '</Billboard>'
        return str


class BlendedVolumeStyle(X3DComposableVolumeRenderStyleNode):
    def __init__(self, **kwargs):
        super(BlendedVolumeStyle, self).__init__(**kwargs)
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        renderStyle  = kwargs.pop("renderStyle", None)
        self.__renderStyle = renderStyle
        voxels  = kwargs.pop("voxels", None)
        self.__voxels = voxels
        weightConstant1  = kwargs.pop("weightConstant1", 0.5)
        if weightConstant1 == None or weightConstant1  <  0:
            return None
        if weightConstant1 == None or weightConstant1  >  1:
            return None
        self.__weightConstant1 = weightConstant1
        weightConstant2  = kwargs.pop("weightConstant2", 0.5)
        if weightConstant2 == None or weightConstant2  <  0:
            return None
        if weightConstant2 == None or weightConstant2  >  1:
            return None
        self.__weightConstant2 = weightConstant2
        weightFunction1  = kwargs.pop("weightFunction1", "CONSTANT")
        if 'CONSTANT' == weightFunction1:
            pass
        elif 'ALPHA1' == weightFunction1:
            pass
        elif 'ALPHA2' == weightFunction1:
            pass
        elif 'ONE_MINUS_ALPHA1' == weightFunction1:
            pass
        elif 'ONE_MINUS_ALPHA2' == weightFunction1:
            pass
        elif 'TABLE' == weightFunction1:
            pass
        else:
            return None
        self.__weightFunction1 = weightFunction1
        weightFunction2  = kwargs.pop("weightFunction2", "CONSTANT")
        if 'CONSTANT' == weightFunction2:
            pass
        elif 'ALPHA1' == weightFunction2:
            pass
        elif 'ALPHA2' == weightFunction2:
            pass
        elif 'ONE_MINUS_ALPHA1' == weightFunction2:
            pass
        elif 'ONE_MINUS_ALPHA2' == weightFunction2:
            pass
        elif 'TABLE' == weightFunction2:
            pass
        else:
            return None
        self.__weightFunction2 = weightFunction2
        weightTransferFunction1  = kwargs.pop("weightTransferFunction1", None)
        self.__weightTransferFunction1 = weightTransferFunction1
        weightTransferFunction2  = kwargs.pop("weightTransferFunction2", None)
        self.__weightTransferFunction2 = weightTransferFunction2
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def renderStyle(self):
        return self.__renderStyle
    @renderStyle.setter
    def renderStyle(self, value = None):
        self.__renderStyle = [value]
    def setRenderStyle(self, renderStyle = None):
        self.__renderStyle = [renderStyle]
        return self
    def addRenderStyle(self, renderStyle = None):
        if self.__renderStyle == None:            self.__renderStyle =  []
        self.__renderStyle +=  [renderStyle]
        return self
    def removeRenderStyle(self, renderStyle):
        self.__renderStyle = [x for x in self.__renderStyle if x not in renderStyle]
        return self.__renderStyle
    def getRenderStyle(self, renderStyle = None):
        return self.__renderStyle
    def renderStyle_changed(self, renderStyle = None):
        return self.__renderStyle
    @property
    def voxels(self):
        return self.__voxels
    @voxels.setter
    def voxels(self, value = None):
        self.__voxels = [value]
    def setVoxels(self, voxels = None):
        self.__voxels = [voxels]
        return self
    def addVoxels(self, voxels = None):
        if self.__voxels == None:            self.__voxels =  []
        self.__voxels +=  [voxels]
        return self
    def removeVoxels(self, voxels):
        self.__voxels = [x for x in self.__voxels if x not in voxels]
        return self.__voxels
    def getVoxels(self, voxels = None):
        return self.__voxels
    def voxels_changed(self, voxels = None):
        return self.__voxels
    @property
    def weightConstant1(self):
        return self.__weightConstant1
    @weightConstant1.setter
    def weightConstant1(self, value = 0.5):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__weightConstant1 = [value]
    def setWeightConstant1(self, weightConstant1 = 0.5):
        if weightConstant1 == None or weightConstant1  <  0:
            return None
        if weightConstant1 == None or weightConstant1  >  1:
            return None
        self.__weightConstant1 = [weightConstant1]
        return self
    def addWeightConstant1(self, weightConstant1 = 0.5):
        if weightConstant1 == None or weightConstant1  <  0:
            return None
        if weightConstant1 == None or weightConstant1  >  1:
            return None
        if self.__weightConstant1 == None:            self.__weightConstant1 =  []
        self.__weightConstant1 +=  [weightConstant1]
        return self
    def removeWeightConstant1(self, weightConstant1):
        self.__weightConstant1 = [x for x in self.__weightConstant1 if x not in weightConstant1]
        return self.__weightConstant1
    def getWeightConstant1(self, weightConstant1 = 0.5):
        return self.__weightConstant1
    def weightConstant1_changed(self, weightConstant1 = 0.5):
        return self.__weightConstant1
    @property
    def weightConstant2(self):
        return self.__weightConstant2
    @weightConstant2.setter
    def weightConstant2(self, value = 0.5):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__weightConstant2 = [value]
    def setWeightConstant2(self, weightConstant2 = 0.5):
        if weightConstant2 == None or weightConstant2  <  0:
            return None
        if weightConstant2 == None or weightConstant2  >  1:
            return None
        self.__weightConstant2 = [weightConstant2]
        return self
    def addWeightConstant2(self, weightConstant2 = 0.5):
        if weightConstant2 == None or weightConstant2  <  0:
            return None
        if weightConstant2 == None or weightConstant2  >  1:
            return None
        if self.__weightConstant2 == None:            self.__weightConstant2 =  []
        self.__weightConstant2 +=  [weightConstant2]
        return self
    def removeWeightConstant2(self, weightConstant2):
        self.__weightConstant2 = [x for x in self.__weightConstant2 if x not in weightConstant2]
        return self.__weightConstant2
    def getWeightConstant2(self, weightConstant2 = 0.5):
        return self.__weightConstant2
    def weightConstant2_changed(self, weightConstant2 = 0.5):
        return self.__weightConstant2
    @property
    def weightFunction1(self):
        return self.__weightFunction1
    @weightFunction1.setter
    def weightFunction1(self, value = "CONSTANT"):
        if 'CONSTANT' == value:
            pass
        elif 'ALPHA1' == value:
            pass
        elif 'ALPHA2' == value:
            pass
        elif 'ONE_MINUS_ALPHA1' == value:
            pass
        elif 'ONE_MINUS_ALPHA2' == value:
            pass
        elif 'TABLE' == value:
            pass
        else:
            return None
        self.__weightFunction1 = [value]
    def setWeightFunction1(self, weightFunction1 = "CONSTANT"):
        if 'CONSTANT' == weightFunction1:
            pass
        elif 'ALPHA1' == weightFunction1:
            pass
        elif 'ALPHA2' == weightFunction1:
            pass
        elif 'ONE_MINUS_ALPHA1' == weightFunction1:
            pass
        elif 'ONE_MINUS_ALPHA2' == weightFunction1:
            pass
        elif 'TABLE' == weightFunction1:
            pass
        else:
            return None
        self.__weightFunction1 = [weightFunction1]
        return self
    def addWeightFunction1(self, weightFunction1 = "CONSTANT"):
        if 'CONSTANT' == weightFunction1:
            pass
        elif 'ALPHA1' == weightFunction1:
            pass
        elif 'ALPHA2' == weightFunction1:
            pass
        elif 'ONE_MINUS_ALPHA1' == weightFunction1:
            pass
        elif 'ONE_MINUS_ALPHA2' == weightFunction1:
            pass
        elif 'TABLE' == weightFunction1:
            pass
        else:
            return None
        if self.__weightFunction1 == None:            self.__weightFunction1 =  []
        self.__weightFunction1 +=  [weightFunction1]
        return self
    def removeWeightFunction1(self, weightFunction1):
        self.__weightFunction1 = [x for x in self.__weightFunction1 if x not in weightFunction1]
        return self.__weightFunction1
    def getWeightFunction1(self, weightFunction1 = "CONSTANT"):
        return self.__weightFunction1
    def weightFunction1_changed(self, weightFunction1 = "CONSTANT"):
        return self.__weightFunction1
    @property
    def weightFunction2(self):
        return self.__weightFunction2
    @weightFunction2.setter
    def weightFunction2(self, value = "CONSTANT"):
        if 'CONSTANT' == value:
            pass
        elif 'ALPHA1' == value:
            pass
        elif 'ALPHA2' == value:
            pass
        elif 'ONE_MINUS_ALPHA1' == value:
            pass
        elif 'ONE_MINUS_ALPHA2' == value:
            pass
        elif 'TABLE' == value:
            pass
        else:
            return None
        self.__weightFunction2 = [value]
    def setWeightFunction2(self, weightFunction2 = "CONSTANT"):
        if 'CONSTANT' == weightFunction2:
            pass
        elif 'ALPHA1' == weightFunction2:
            pass
        elif 'ALPHA2' == weightFunction2:
            pass
        elif 'ONE_MINUS_ALPHA1' == weightFunction2:
            pass
        elif 'ONE_MINUS_ALPHA2' == weightFunction2:
            pass
        elif 'TABLE' == weightFunction2:
            pass
        else:
            return None
        self.__weightFunction2 = [weightFunction2]
        return self
    def addWeightFunction2(self, weightFunction2 = "CONSTANT"):
        if 'CONSTANT' == weightFunction2:
            pass
        elif 'ALPHA1' == weightFunction2:
            pass
        elif 'ALPHA2' == weightFunction2:
            pass
        elif 'ONE_MINUS_ALPHA1' == weightFunction2:
            pass
        elif 'ONE_MINUS_ALPHA2' == weightFunction2:
            pass
        elif 'TABLE' == weightFunction2:
            pass
        else:
            return None
        if self.__weightFunction2 == None:            self.__weightFunction2 =  []
        self.__weightFunction2 +=  [weightFunction2]
        return self
    def removeWeightFunction2(self, weightFunction2):
        self.__weightFunction2 = [x for x in self.__weightFunction2 if x not in weightFunction2]
        return self.__weightFunction2
    def getWeightFunction2(self, weightFunction2 = "CONSTANT"):
        return self.__weightFunction2
    def weightFunction2_changed(self, weightFunction2 = "CONSTANT"):
        return self.__weightFunction2
    @property
    def weightTransferFunction1(self):
        return self.__weightTransferFunction1
    @weightTransferFunction1.setter
    def weightTransferFunction1(self, value = None):
        self.__weightTransferFunction1 = [value]
    def setWeightTransferFunction1(self, weightTransferFunction1 = None):
        self.__weightTransferFunction1 = [weightTransferFunction1]
        return self
    def addWeightTransferFunction1(self, weightTransferFunction1 = None):
        if self.__weightTransferFunction1 == None:            self.__weightTransferFunction1 =  []
        self.__weightTransferFunction1 +=  [weightTransferFunction1]
        return self
    def removeWeightTransferFunction1(self, weightTransferFunction1):
        self.__weightTransferFunction1 = [x for x in self.__weightTransferFunction1 if x not in weightTransferFunction1]
        return self.__weightTransferFunction1
    def getWeightTransferFunction1(self, weightTransferFunction1 = None):
        return self.__weightTransferFunction1
    def weightTransferFunction1_changed(self, weightTransferFunction1 = None):
        return self.__weightTransferFunction1
    @property
    def weightTransferFunction2(self):
        return self.__weightTransferFunction2
    @weightTransferFunction2.setter
    def weightTransferFunction2(self, value = None):
        self.__weightTransferFunction2 = [value]
    def setWeightTransferFunction2(self, weightTransferFunction2 = None):
        self.__weightTransferFunction2 = [weightTransferFunction2]
        return self
    def addWeightTransferFunction2(self, weightTransferFunction2 = None):
        if self.__weightTransferFunction2 == None:            self.__weightTransferFunction2 =  []
        self.__weightTransferFunction2 +=  [weightTransferFunction2]
        return self
    def removeWeightTransferFunction2(self, weightTransferFunction2):
        self.__weightTransferFunction2 = [x for x in self.__weightTransferFunction2 if x not in weightTransferFunction2]
        return self.__weightTransferFunction2
    def getWeightTransferFunction2(self, weightTransferFunction2 = None):
        return self.__weightTransferFunction2
    def weightTransferFunction2_changed(self, weightTransferFunction2 = None):
        return self.__weightTransferFunction2
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<BlendedVolumeStyle'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__weightConstant1 is not None:
            if isinstance(self.__weightConstant1, six.string_types):
                str += ' weightConstant1="'+self.__weightConstant1+'"'
            else:
                str += ' weightConstant1="'+self.__weightConstant1[0]+'"'
        if self.__weightConstant2 is not None:
            if isinstance(self.__weightConstant2, six.string_types):
                str += ' weightConstant2="'+self.__weightConstant2+'"'
            else:
                str += ' weightConstant2="'+self.__weightConstant2[0]+'"'
        if self.__weightFunction1 is not None:
            if isinstance(self.__weightFunction1, six.string_types):
                str += ' weightFunction1="'+self.__weightFunction1+'"'
            else:
                str += ' weightFunction1="'+self.__weightFunction1[0]+'"'
        if self.__weightFunction2 is not None:
            if isinstance(self.__weightFunction2, six.string_types):
                str += ' weightFunction2="'+self.__weightFunction2+'"'
            else:
                str += ' weightFunction2="'+self.__weightFunction2[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<renderStyle'
        if self.__renderStyle is not None:
           for s in self.__renderStyle:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__renderStyle is not None:
           for s in self.__renderStyle:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</renderStyle>'
        str += '<voxels'
        if self.__voxels is not None:
           for s in self.__voxels:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__voxels is not None:
           for s in self.__voxels:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</voxels>'
        str += '<weightTransferFunction1'
        if self.__weightTransferFunction1 is not None:
           for s in self.__weightTransferFunction1:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__weightTransferFunction1 is not None:
           for s in self.__weightTransferFunction1:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</weightTransferFunction1>'
        str += '<weightTransferFunction2'
        if self.__weightTransferFunction2 is not None:
           for s in self.__weightTransferFunction2:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__weightTransferFunction2 is not None:
           for s in self.__weightTransferFunction2:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</weightTransferFunction2>'
        str += '</BlendedVolumeStyle>'
        return str


class BooleanFilter(X3DChildNode):
    def __init__(self, **kwargs):
        super(BooleanFilter, self).__init__(**kwargs)
        inputFalse  = kwargs.pop("inputFalse", None)
        self.__inputFalse = inputFalse
        inputNegate  = kwargs.pop("inputNegate", None)
        self.__inputNegate = inputNegate
        inputTrue  = kwargs.pop("inputTrue", None)
        self.__inputTrue = inputTrue
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        boolean  = kwargs.pop("boolean", None)
        self.__boolean = boolean
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def removeInputFalse(self, inputFalse):
        self.__inputFalse = [x for x in self.__inputFalse if x not in inputFalse]
        return self.__inputFalse
    def isInputFalse(self, inputFalse = None):
        return self.__inputFalse
    def removeInputNegate(self, inputNegate):
        self.__inputNegate = [x for x in self.__inputNegate if x not in inputNegate]
        return self.__inputNegate
    def isInputNegate(self, inputNegate = None):
        return self.__inputNegate
    def removeInputTrue(self, inputTrue):
        self.__inputTrue = [x for x in self.__inputTrue if x not in inputTrue]
        return self.__inputTrue
    def isInputTrue(self, inputTrue = None):
        return self.__inputTrue
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def boolean(self):
        return self.__boolean
    @boolean.setter
    def boolean(self, value = None):
        self.__boolean = [value]
    def set_boolean(self, boolean = None):
        self.__boolean = [boolean]
        return self
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<BooleanFilter'
        if self.__inputFalse is not None:
            if isinstance(self.__inputFalse, six.string_types):
                str += ' inputFalse="'+self.__inputFalse+'"'
            else:
                str += ' inputFalse="'+self.__inputFalse[0]+'"'
        if self.__inputNegate is not None:
            if isinstance(self.__inputNegate, six.string_types):
                str += ' inputNegate="'+self.__inputNegate+'"'
            else:
                str += ' inputNegate="'+self.__inputNegate[0]+'"'
        if self.__inputTrue is not None:
            if isinstance(self.__inputTrue, six.string_types):
                str += ' inputTrue="'+self.__inputTrue+'"'
            else:
                str += ' inputTrue="'+self.__inputTrue[0]+'"'
        if self.__boolean is not None:
            if isinstance(self.__boolean, six.string_types):
                str += ' boolean="'+self.__boolean+'"'
            else:
                str += ' boolean="'+self.__boolean[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</BooleanFilter>'
        return str


class BooleanSequencer(X3DSequencerNode):
    def __init__(self, **kwargs):
        super(BooleanSequencer, self).__init__(**kwargs)
        key  = kwargs.pop("key", None)
        self.__key = key
        keyValue  = kwargs.pop("keyValue", None)
        self.__keyValue = keyValue
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        next  = kwargs.pop("next", None)
        self.__next = next
        previous  = kwargs.pop("previous", None)
        self.__previous = previous
        fraction  = kwargs.pop("fraction", None)
        self.__fraction = fraction
        value_changed  = kwargs.pop("value_changed", None)
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def key(self):
        return self.__key
    @key.setter
    def key(self, value = None):
        self.__key = [value]
    def setKey(self, key = None):
        self.__key = [key]
        return self
    def addKey(self, key = None):
        if self.__key == None:            self.__key =  []
        self.__key +=  [key]
        return self
    def removeKey(self, key):
        self.__key = [x for x in self.__key if x not in key]
        return self.__key
    def getKey(self, key = None):
        return self.__key
    def key_changed(self, key = None):
        return self.__key
    @property
    def keyValue(self):
        return self.__keyValue
    @keyValue.setter
    def keyValue(self, value = None):
        self.__keyValue = [value]
    def setKeyValue(self, keyValue = None):
        self.__keyValue = [keyValue]
        return self
    def addKeyValue(self, keyValue = None):
        if self.__keyValue == None:            self.__keyValue =  []
        self.__keyValue +=  [keyValue]
        return self
    def removeKeyValue(self, keyValue):
        self.__keyValue = [x for x in self.__keyValue if x not in keyValue]
        return self.__keyValue
    def getKeyValue(self, keyValue = None):
        return self.__keyValue
    def keyValue_changed(self, keyValue = None):
        return self.__keyValue
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def next(self):
        return self.__next
    @next.setter
    def next(self, value = None):
        self.__next = [value]
    def setNext(self, next = None):
        self.__next = [next]
        return self
    def addNext(self, next = None):
        if self.__next == None:            self.__next =  []
        self.__next +=  [next]
        return self
    @property
    def previous(self):
        return self.__previous
    @previous.setter
    def previous(self, value = None):
        self.__previous = [value]
    def setPrevious(self, previous = None):
        self.__previous = [previous]
        return self
    def addPrevious(self, previous = None):
        if self.__previous == None:            self.__previous =  []
        self.__previous +=  [previous]
        return self
    @property
    def fraction(self):
        return self.__fraction
    @fraction.setter
    def fraction(self, value = None):
        self.__fraction = [value]
    def set_fraction(self, fraction = None):
        self.__fraction = [fraction]
        return self
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def isvalue_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<BooleanSequencer'
        if self.__key is not None:
            if isinstance(self.__key, six.string_types):
                str += ' key="'+self.__key+'"'
            else:
                str += ' key="'+self.__key[0]+'"'
        if self.__keyValue is not None:
            if isinstance(self.__keyValue, six.string_types):
                str += ' keyValue="'+self.__keyValue+'"'
            else:
                str += ' keyValue="'+self.__keyValue[0]+'"'
        if self.__next is not None:
            if isinstance(self.__next, six.string_types):
                str += ' next="'+self.__next+'"'
            else:
                str += ' next="'+self.__next[0]+'"'
        if self.__previous is not None:
            if isinstance(self.__previous, six.string_types):
                str += ' previous="'+self.__previous+'"'
            else:
                str += ' previous="'+self.__previous[0]+'"'
        if self.__fraction is not None:
            if isinstance(self.__fraction, six.string_types):
                str += ' fraction="'+self.__fraction+'"'
            else:
                str += ' fraction="'+self.__fraction[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</BooleanSequencer>'
        return str


class BooleanToggle(X3DChildNode):
    def __init__(self, **kwargs):
        super(BooleanToggle, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        boolean  = kwargs.pop("boolean", None)
        self.__boolean = boolean
        toggle  = kwargs.pop("toggle", False)
        self.__toggle = toggle
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def boolean(self):
        return self.__boolean
    @boolean.setter
    def boolean(self, value = None):
        self.__boolean = [value]
    def set_boolean(self, boolean = None):
        self.__boolean = [boolean]
        return self
    @property
    def toggle(self):
        return self.__toggle
    @toggle.setter
    def toggle(self, value = False):
        self.__toggle = [value]
    def setToggle(self, toggle = False):
        self.__toggle = [toggle]
        return self
    def addToggle(self, toggle = False):
        if self.__toggle == None:            self.__toggle =  []
        self.__toggle +=  [toggle]
        return self
    def removeToggle(self, toggle):
        self.__toggle = [x for x in self.__toggle if x not in toggle]
        return self.__toggle
    def isToggle(self, toggle = False):
        return self.__toggle
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<BooleanToggle'
        if self.__boolean is not None:
            if isinstance(self.__boolean, six.string_types):
                str += ' boolean="'+self.__boolean+'"'
            else:
                str += ' boolean="'+self.__boolean[0]+'"'
        if self.__toggle is not None:
            if isinstance(self.__toggle, six.string_types):
                str += ' toggle="'+self.__toggle+'"'
            else:
                str += ' toggle="'+self.__toggle[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</BooleanToggle>'
        return str


class BooleanTrigger(X3DTriggerNode):
    def __init__(self, **kwargs):
        super(BooleanTrigger, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        triggerTime  = kwargs.pop("triggerTime", None)
        self.__triggerTime = triggerTime
        triggerTrue  = kwargs.pop("triggerTrue", None)
        self.__triggerTrue = triggerTrue
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def triggerTime(self):
        return self.__triggerTime
    @triggerTime.setter
    def triggerTime(self, value = None):
        self.__triggerTime = [value]
    def set_triggerTime(self, triggerTime = None):
        self.__triggerTime = [triggerTime]
        return self
    def removeTriggerTrue(self, triggerTrue):
        self.__triggerTrue = [x for x in self.__triggerTrue if x not in triggerTrue]
        return self.__triggerTrue
    def isTriggerTrue(self, triggerTrue = None):
        return self.__triggerTrue
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<BooleanTrigger'
        if self.__triggerTime is not None:
            if isinstance(self.__triggerTime, six.string_types):
                str += ' triggerTime="'+self.__triggerTime+'"'
            else:
                str += ' triggerTime="'+self.__triggerTime[0]+'"'
        if self.__triggerTrue is not None:
            if isinstance(self.__triggerTrue, six.string_types):
                str += ' triggerTrue="'+self.__triggerTrue+'"'
            else:
                str += ' triggerTrue="'+self.__triggerTrue[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</BooleanTrigger>'
        return str


class BoundaryEnhancementVolumeStyle(X3DComposableVolumeRenderStyleNode):
    def __init__(self, **kwargs):
        super(BoundaryEnhancementVolumeStyle, self).__init__(**kwargs)
        boundaryOpacity  = kwargs.pop("boundaryOpacity", 0.9)
        if boundaryOpacity == None or boundaryOpacity  <  0:
            return None
        if boundaryOpacity == None or boundaryOpacity  >  1:
            return None
        self.__boundaryOpacity = boundaryOpacity
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        opacityFactor  = kwargs.pop("opacityFactor", 2)
        if opacityFactor == None or opacityFactor  <  0:
            return None
        self.__opacityFactor = opacityFactor
        retainedOpacity  = kwargs.pop("retainedOpacity", 0.2)
        if retainedOpacity == None or retainedOpacity  <  0:
            return None
        if retainedOpacity == None or retainedOpacity  >  1:
            return None
        self.__retainedOpacity = retainedOpacity
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def boundaryOpacity(self):
        return self.__boundaryOpacity
    @boundaryOpacity.setter
    def boundaryOpacity(self, value = 0.9):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__boundaryOpacity = [value]
    def setBoundaryOpacity(self, boundaryOpacity = 0.9):
        if boundaryOpacity == None or boundaryOpacity  <  0:
            return None
        if boundaryOpacity == None or boundaryOpacity  >  1:
            return None
        self.__boundaryOpacity = [boundaryOpacity]
        return self
    def addBoundaryOpacity(self, boundaryOpacity = 0.9):
        if boundaryOpacity == None or boundaryOpacity  <  0:
            return None
        if boundaryOpacity == None or boundaryOpacity  >  1:
            return None
        if self.__boundaryOpacity == None:            self.__boundaryOpacity =  []
        self.__boundaryOpacity +=  [boundaryOpacity]
        return self
    def removeBoundaryOpacity(self, boundaryOpacity):
        self.__boundaryOpacity = [x for x in self.__boundaryOpacity if x not in boundaryOpacity]
        return self.__boundaryOpacity
    def getBoundaryOpacity(self, boundaryOpacity = 0.9):
        return self.__boundaryOpacity
    def boundaryOpacity_changed(self, boundaryOpacity = 0.9):
        return self.__boundaryOpacity
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def opacityFactor(self):
        return self.__opacityFactor
    @opacityFactor.setter
    def opacityFactor(self, value = 2):
        if value == None or value  <  0:
            return None
        self.__opacityFactor = [value]
    def setOpacityFactor(self, opacityFactor = 2):
        if opacityFactor == None or opacityFactor  <  0:
            return None
        self.__opacityFactor = [opacityFactor]
        return self
    def addOpacityFactor(self, opacityFactor = 2):
        if opacityFactor == None or opacityFactor  <  0:
            return None
        if self.__opacityFactor == None:            self.__opacityFactor =  []
        self.__opacityFactor +=  [opacityFactor]
        return self
    def removeOpacityFactor(self, opacityFactor):
        self.__opacityFactor = [x for x in self.__opacityFactor if x not in opacityFactor]
        return self.__opacityFactor
    def getOpacityFactor(self, opacityFactor = 2):
        return self.__opacityFactor
    def opacityFactor_changed(self, opacityFactor = 2):
        return self.__opacityFactor
    @property
    def retainedOpacity(self):
        return self.__retainedOpacity
    @retainedOpacity.setter
    def retainedOpacity(self, value = 0.2):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__retainedOpacity = [value]
    def setRetainedOpacity(self, retainedOpacity = 0.2):
        if retainedOpacity == None or retainedOpacity  <  0:
            return None
        if retainedOpacity == None or retainedOpacity  >  1:
            return None
        self.__retainedOpacity = [retainedOpacity]
        return self
    def addRetainedOpacity(self, retainedOpacity = 0.2):
        if retainedOpacity == None or retainedOpacity  <  0:
            return None
        if retainedOpacity == None or retainedOpacity  >  1:
            return None
        if self.__retainedOpacity == None:            self.__retainedOpacity =  []
        self.__retainedOpacity +=  [retainedOpacity]
        return self
    def removeRetainedOpacity(self, retainedOpacity):
        self.__retainedOpacity = [x for x in self.__retainedOpacity if x not in retainedOpacity]
        return self.__retainedOpacity
    def getRetainedOpacity(self, retainedOpacity = 0.2):
        return self.__retainedOpacity
    def retainedOpacity_changed(self, retainedOpacity = 0.2):
        return self.__retainedOpacity
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<BoundaryEnhancementVolumeStyle'
        if self.__boundaryOpacity is not None:
            if isinstance(self.__boundaryOpacity, six.string_types):
                str += ' boundaryOpacity="'+self.__boundaryOpacity+'"'
            else:
                str += ' boundaryOpacity="'+self.__boundaryOpacity[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__opacityFactor is not None:
            if isinstance(self.__opacityFactor, six.string_types):
                str += ' opacityFactor="'+self.__opacityFactor+'"'
            else:
                str += ' opacityFactor="'+self.__opacityFactor[0]+'"'
        if self.__retainedOpacity is not None:
            if isinstance(self.__retainedOpacity, six.string_types):
                str += ' retainedOpacity="'+self.__retainedOpacity+'"'
            else:
                str += ' retainedOpacity="'+self.__retainedOpacity[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</BoundaryEnhancementVolumeStyle>'
        return str


class BoundedPhysicsModel(X3DParticlePhysicsModelNode):
    def __init__(self, **kwargs):
        super(BoundedPhysicsModel, self).__init__(**kwargs)
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        geometry  = kwargs.pop("geometry", None)
        self.__geometry = geometry
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def geometry(self):
        return self.__geometry
    @geometry.setter
    def geometry(self, value = None):
        self.__geometry = [value]
    def setGeometry(self, geometry = None):
        self.__geometry = [geometry]
        return self
    def addGeometry(self, geometry = None):
        if self.__geometry == None:            self.__geometry =  []
        self.__geometry +=  [geometry]
        return self
    def removeGeometry(self, geometry):
        self.__geometry = [x for x in self.__geometry if x not in geometry]
        return self.__geometry
    def getGeometry(self, geometry = None):
        return self.__geometry
    def geometry_changed(self, geometry = None):
        return self.__geometry
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<BoundedPhysicsModel'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<geometry'
        if self.__geometry is not None:
           for s in self.__geometry:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__geometry is not None:
           for s in self.__geometry:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</geometry>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</BoundedPhysicsModel>'
        return str


class Box(X3DGeometryNode):
    def __init__(self, **kwargs):
        super(Box, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        size  = kwargs.pop("size", [2, 2, 2])
        self.__size = size
        solid  = kwargs.pop("solid", True)
        self.__solid = solid
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Box'
        if self.__size is not None:
            if isinstance(self.__size, six.string_types):
                str += ' size="'+self.__size+'"'
            else:
                str += ' size="'+self.__size[0]+'"'
        if self.__solid is not None:
            if isinstance(self.__solid, six.string_types):
                str += ' solid="'+self.__solid+'"'
            else:
                str += ' solid="'+self.__solid[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</Box>'
        return str


class CADAssembly(X3DProductStructureChildNode, X3DGroupingNode):
    def __init__(self, **kwargs):
        super(CADAssembly, self).__init__(**kwargs)
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        children  = kwargs.pop("children", None)
        self.__children = children
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        name  = kwargs.pop("name", None)
        self.__name = name
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    def addChildren(self, Children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [Children]
        return self
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        self.__name = [value]
    def setName(self, name = None):
        self.__name = [name]
        return self
    def addName(self, name = None):
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<CADAssembly'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '</CADAssembly>'
        return str


class CADFace(X3DBoundedObject, X3DProductStructureChildNode):
    def __init__(self, **kwargs):
        super(CADFace, self).__init__(**kwargs)
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        name  = kwargs.pop("name", None)
        self.__name = name
        shape  = kwargs.pop("shape", None)
        self.__shape = shape
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        self.__name = [value]
    def setName(self, name = None):
        self.__name = [name]
        return self
    def addName(self, name = None):
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def shape(self):
        return self.__shape
    @shape.setter
    def shape(self, value = None):
        self.__shape = [value]
    def setShape(self, shape = None):
        self.__shape = [shape]
        return self
    def addShape(self, shape = None):
        if self.__shape == None:            self.__shape =  []
        self.__shape +=  [shape]
        return self
    def removeShape(self, shape):
        self.__shape = [x for x in self.__shape if x not in shape]
        return self.__shape
    def getShape(self, shape = None):
        return self.__shape
    def shape_changed(self, shape = None):
        return self.__shape
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<CADFace'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<shape'
        if self.__shape is not None:
           for s in self.__shape:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__shape is not None:
           for s in self.__shape:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</shape>'
        str += '</CADFace>'
        return str


class CADLayer(X3DGroupingNode):
    def __init__(self, **kwargs):
        super(CADLayer, self).__init__(**kwargs)
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        children  = kwargs.pop("children", None)
        self.__children = children
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        name  = kwargs.pop("name", None)
        self.__name = name
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        visible  = kwargs.pop("visible", None)
        self.__visible = visible
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    def addChildren(self, Children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [Children]
        return self
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        self.__name = [value]
    def setName(self, name = None):
        self.__name = [name]
        return self
    def addName(self, name = None):
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    @property
    def visible(self):
        return self.__visible
    @visible.setter
    def visible(self, value = None):
        self.__visible = [value]
    def setVisible(self, visible = None):
        self.__visible = [visible]
        return self
    def addVisible(self, visible = None):
        if self.__visible == None:            self.__visible =  []
        self.__visible +=  [visible]
        return self
    def removeVisible(self, visible):
        self.__visible = [x for x in self.__visible if x not in visible]
        return self.__visible
    def getVisible(self, visible = None):
        return self.__visible
    def visible_changed(self, visible = None):
        return self.__visible
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<CADLayer'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        if self.__visible is not None:
            if isinstance(self.__visible, six.string_types):
                str += ' visible="'+self.__visible+'"'
            else:
                str += ' visible="'+self.__visible[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '</CADLayer>'
        return str


class CADPart(X3DGroupingNode, X3DProductStructureChildNode):
    def __init__(self, **kwargs):
        super(CADPart, self).__init__(**kwargs)
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        center  = kwargs.pop("center", [0, 0, 0])
        self.__center = center
        children  = kwargs.pop("children", None)
        self.__children = children
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        name  = kwargs.pop("name", None)
        self.__name = name
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        rotation  = kwargs.pop("rotation", [0, 0, 1, 0])
        self.__rotation = rotation
        scale  = kwargs.pop("scale", [1, 1, 1])
        self.__scale = scale
        scaleOrientation  = kwargs.pop("scaleOrientation", [0, 0, 1, 0])
        self.__scaleOrientation = scaleOrientation
        translation  = kwargs.pop("translation", [0, 0, 0])
        self.__translation = translation
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    def addChildren(self, Children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [Children]
        return self
    @property
    def center(self):
        return self.__center
    @center.setter
    def center(self, value = [0, 0, 0]):
        self.__center = [value]
    def setCenter(self, center = [0, 0, 0]):
        self.__center = [center]
        return self
    def addCenter(self, center = [0, 0, 0]):
        if self.__center == None:            self.__center =  []
        self.__center +=  [center]
        return self
    def removeCenter(self, center):
        self.__center = [x for x in self.__center if x not in center]
        return self.__center
    def getCenter(self, center = [0, 0, 0]):
        return self.__center
    def center_changed(self, center = [0, 0, 0]):
        return self.__center
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        self.__name = [value]
    def setName(self, name = None):
        self.__name = [name]
        return self
    def addName(self, name = None):
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    @property
    def rotation(self):
        return self.__rotation
    @rotation.setter
    def rotation(self, value = [0, 0, 1, 0]):
        self.__rotation = [value]
    def setRotation(self, rotation = [0, 0, 1, 0]):
        self.__rotation = [rotation]
        return self
    def addRotation(self, rotation = [0, 0, 1, 0]):
        if self.__rotation == None:            self.__rotation =  []
        self.__rotation +=  [rotation]
        return self
    def removeRotation(self, rotation):
        self.__rotation = [x for x in self.__rotation if x not in rotation]
        return self.__rotation
    def getRotation(self, rotation = [0, 0, 1, 0]):
        return self.__rotation
    def rotation_changed(self, rotation = [0, 0, 1, 0]):
        return self.__rotation
    @property
    def scale(self):
        return self.__scale
    @scale.setter
    def scale(self, value = [1, 1, 1]):
        self.__scale = [value]
    def setScale(self, scale = [1, 1, 1]):
        self.__scale = [scale]
        return self
    def addScale(self, scale = [1, 1, 1]):
        if self.__scale == None:            self.__scale =  []
        self.__scale +=  [scale]
        return self
    def removeScale(self, scale):
        self.__scale = [x for x in self.__scale if x not in scale]
        return self.__scale
    def getScale(self, scale = [1, 1, 1]):
        return self.__scale
    def scale_changed(self, scale = [1, 1, 1]):
        return self.__scale
    @property
    def scaleOrientation(self):
        return self.__scaleOrientation
    @scaleOrientation.setter
    def scaleOrientation(self, value = [0, 0, 1, 0]):
        self.__scaleOrientation = [value]
    def setScaleOrientation(self, scaleOrientation = [0, 0, 1, 0]):
        self.__scaleOrientation = [scaleOrientation]
        return self
    def addScaleOrientation(self, scaleOrientation = [0, 0, 1, 0]):
        if self.__scaleOrientation == None:            self.__scaleOrientation =  []
        self.__scaleOrientation +=  [scaleOrientation]
        return self
    def removeScaleOrientation(self, scaleOrientation):
        self.__scaleOrientation = [x for x in self.__scaleOrientation if x not in scaleOrientation]
        return self.__scaleOrientation
    def getScaleOrientation(self, scaleOrientation = [0, 0, 1, 0]):
        return self.__scaleOrientation
    def scaleOrientation_changed(self, scaleOrientation = [0, 0, 1, 0]):
        return self.__scaleOrientation
    @property
    def translation(self):
        return self.__translation
    @translation.setter
    def translation(self, value = [0, 0, 0]):
        self.__translation = [value]
    def setTranslation(self, translation = [0, 0, 0]):
        self.__translation = [translation]
        return self
    def addTranslation(self, translation = [0, 0, 0]):
        if self.__translation == None:            self.__translation =  []
        self.__translation +=  [translation]
        return self
    def removeTranslation(self, translation):
        self.__translation = [x for x in self.__translation if x not in translation]
        return self.__translation
    def getTranslation(self, translation = [0, 0, 0]):
        return self.__translation
    def translation_changed(self, translation = [0, 0, 0]):
        return self.__translation
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<CADPart'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__center is not None:
            if isinstance(self.__center, six.string_types):
                str += ' center="'+self.__center+'"'
            else:
                str += ' center="'+self.__center[0]+'"'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        if self.__rotation is not None:
            if isinstance(self.__rotation, six.string_types):
                str += ' rotation="'+self.__rotation+'"'
            else:
                str += ' rotation="'+self.__rotation[0]+'"'
        if self.__scale is not None:
            if isinstance(self.__scale, six.string_types):
                str += ' scale="'+self.__scale+'"'
            else:
                str += ' scale="'+self.__scale[0]+'"'
        if self.__scaleOrientation is not None:
            if isinstance(self.__scaleOrientation, six.string_types):
                str += ' scaleOrientation="'+self.__scaleOrientation+'"'
            else:
                str += ' scaleOrientation="'+self.__scaleOrientation[0]+'"'
        if self.__translation is not None:
            if isinstance(self.__translation, six.string_types):
                str += ' translation="'+self.__translation+'"'
            else:
                str += ' translation="'+self.__translation[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '</CADPart>'
        return str


class CartoonVolumeStyle(X3DComposableVolumeRenderStyleNode):
    def __init__(self, **kwargs):
        super(CartoonVolumeStyle, self).__init__(**kwargs)
        colorSteps  = kwargs.pop("colorSteps", 4)
        if colorSteps == None or colorSteps  <  1:
            return None
        if colorSteps == None or colorSteps  >  64:
            return None
        self.__colorSteps = colorSteps
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        orthogonalColor  = kwargs.pop("orthogonalColor", [1, 1, 1, 1])
        if orthogonalColor == None or orthogonalColor  <  0:
            return None
        if orthogonalColor == None or orthogonalColor  >  1:
            return None
        self.__orthogonalColor = orthogonalColor
        parallelColor  = kwargs.pop("parallelColor", [0, 0, 0, 1])
        if parallelColor == None or parallelColor  <  0:
            return None
        if parallelColor == None or parallelColor  >  1:
            return None
        self.__parallelColor = parallelColor
        surfaceNormals  = kwargs.pop("surfaceNormals", None)
        self.__surfaceNormals = surfaceNormals
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def colorSteps(self):
        return self.__colorSteps
    @colorSteps.setter
    def colorSteps(self, value = 4):
        if value == None or value  <  1:
            return None
        if value == None or value  >  64:
            return None
        self.__colorSteps = [value]
    def setColorSteps(self, colorSteps = 4):
        if colorSteps == None or colorSteps  <  1:
            return None
        if colorSteps == None or colorSteps  >  64:
            return None
        self.__colorSteps = [colorSteps]
        return self
    def addColorSteps(self, colorSteps = 4):
        if colorSteps == None or colorSteps  <  1:
            return None
        if colorSteps == None or colorSteps  >  64:
            return None
        if self.__colorSteps == None:            self.__colorSteps =  []
        self.__colorSteps +=  [colorSteps]
        return self
    def removeColorSteps(self, colorSteps):
        self.__colorSteps = [x for x in self.__colorSteps if x not in colorSteps]
        return self.__colorSteps
    def getColorSteps(self, colorSteps = 4):
        return self.__colorSteps
    def colorSteps_changed(self, colorSteps = 4):
        return self.__colorSteps
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def orthogonalColor(self):
        return self.__orthogonalColor
    @orthogonalColor.setter
    def orthogonalColor(self, value = [1, 1, 1, 1]):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__orthogonalColor = [value]
    def setOrthogonalColor(self, orthogonalColor = [1, 1, 1, 1]):
        if orthogonalColor == None or orthogonalColor  <  0:
            return None
        if orthogonalColor == None or orthogonalColor  >  1:
            return None
        self.__orthogonalColor = [orthogonalColor]
        return self
    def addOrthogonalColor(self, orthogonalColor = [1, 1, 1, 1]):
        if orthogonalColor == None or orthogonalColor  <  0:
            return None
        if orthogonalColor == None or orthogonalColor  >  1:
            return None
        if self.__orthogonalColor == None:            self.__orthogonalColor =  []
        self.__orthogonalColor +=  [orthogonalColor]
        return self
    def removeOrthogonalColor(self, orthogonalColor):
        self.__orthogonalColor = [x for x in self.__orthogonalColor if x not in orthogonalColor]
        return self.__orthogonalColor
    def getOrthogonalColor(self, orthogonalColor = [1, 1, 1, 1]):
        return self.__orthogonalColor
    def orthogonalColor_changed(self, orthogonalColor = [1, 1, 1, 1]):
        return self.__orthogonalColor
    @property
    def parallelColor(self):
        return self.__parallelColor
    @parallelColor.setter
    def parallelColor(self, value = [0, 0, 0, 1]):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__parallelColor = [value]
    def setParallelColor(self, parallelColor = [0, 0, 0, 1]):
        if parallelColor == None or parallelColor  <  0:
            return None
        if parallelColor == None or parallelColor  >  1:
            return None
        self.__parallelColor = [parallelColor]
        return self
    def addParallelColor(self, parallelColor = [0, 0, 0, 1]):
        if parallelColor == None or parallelColor  <  0:
            return None
        if parallelColor == None or parallelColor  >  1:
            return None
        if self.__parallelColor == None:            self.__parallelColor =  []
        self.__parallelColor +=  [parallelColor]
        return self
    def removeParallelColor(self, parallelColor):
        self.__parallelColor = [x for x in self.__parallelColor if x not in parallelColor]
        return self.__parallelColor
    def getParallelColor(self, parallelColor = [0, 0, 0, 1]):
        return self.__parallelColor
    def parallelColor_changed(self, parallelColor = [0, 0, 0, 1]):
        return self.__parallelColor
    @property
    def surfaceNormals(self):
        return self.__surfaceNormals
    @surfaceNormals.setter
    def surfaceNormals(self, value = None):
        self.__surfaceNormals = [value]
    def setSurfaceNormals(self, surfaceNormals = None):
        self.__surfaceNormals = [surfaceNormals]
        return self
    def addSurfaceNormals(self, surfaceNormals = None):
        if self.__surfaceNormals == None:            self.__surfaceNormals =  []
        self.__surfaceNormals +=  [surfaceNormals]
        return self
    def removeSurfaceNormals(self, surfaceNormals):
        self.__surfaceNormals = [x for x in self.__surfaceNormals if x not in surfaceNormals]
        return self.__surfaceNormals
    def getSurfaceNormals(self, surfaceNormals = None):
        return self.__surfaceNormals
    def surfaceNormals_changed(self, surfaceNormals = None):
        return self.__surfaceNormals
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<CartoonVolumeStyle'
        if self.__colorSteps is not None:
            if isinstance(self.__colorSteps, six.string_types):
                str += ' colorSteps="'+self.__colorSteps+'"'
            else:
                str += ' colorSteps="'+self.__colorSteps[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__orthogonalColor is not None:
            if isinstance(self.__orthogonalColor, six.string_types):
                str += ' orthogonalColor="'+self.__orthogonalColor+'"'
            else:
                str += ' orthogonalColor="'+self.__orthogonalColor[0]+'"'
        if self.__parallelColor is not None:
            if isinstance(self.__parallelColor, six.string_types):
                str += ' parallelColor="'+self.__parallelColor+'"'
            else:
                str += ' parallelColor="'+self.__parallelColor[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<surfaceNormals'
        if self.__surfaceNormals is not None:
           for s in self.__surfaceNormals:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__surfaceNormals is not None:
           for s in self.__surfaceNormals:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</surfaceNormals>'
        str += '</CartoonVolumeStyle>'
        return str


class Circle2D(X3DGeometryNode):
    def __init__(self, **kwargs):
        super(Circle2D, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        radius  = kwargs.pop("radius", 1)
        if radius == None or radius  <=  0:
            return None
        self.__radius = radius
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Circle2D'
        if self.__radius is not None:
            if isinstance(self.__radius, six.string_types):
                str += ' radius="'+self.__radius+'"'
            else:
                str += ' radius="'+self.__radius[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</Circle2D>'
        return str


class ClipPlane(X3DChildNode):
    def __init__(self, **kwargs):
        super(ClipPlane, self).__init__(**kwargs)
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        plane  = kwargs.pop("plane", [0, 1, 0, 0])
        if plane == None or plane  <  -1:
            return None
        if plane == None or plane  >  1:
            return None
        self.__plane = plane
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def plane(self):
        return self.__plane
    @plane.setter
    def plane(self, value = [0, 1, 0, 0]):
        if value == None or value  <  -1:
            return None
        if value == None or value  >  1:
            return None
        self.__plane = [value]
    def setPlane(self, plane = [0, 1, 0, 0]):
        if plane == None or plane  <  -1:
            return None
        if plane == None or plane  >  1:
            return None
        self.__plane = [plane]
        return self
    def addPlane(self, plane = [0, 1, 0, 0]):
        if plane == None or plane  <  -1:
            return None
        if plane == None or plane  >  1:
            return None
        if self.__plane == None:            self.__plane =  []
        self.__plane +=  [plane]
        return self
    def removePlane(self, plane):
        self.__plane = [x for x in self.__plane if x not in plane]
        return self.__plane
    def getPlane(self, plane = [0, 1, 0, 0]):
        return self.__plane
    def plane_changed(self, plane = [0, 1, 0, 0]):
        return self.__plane
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ClipPlane'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__plane is not None:
            if isinstance(self.__plane, six.string_types):
                str += ' plane="'+self.__plane+'"'
            else:
                str += ' plane="'+self.__plane[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</ClipPlane>'
        return str


class CollidableOffset(X3DNBodyCollidableNode):
    def __init__(self, **kwargs):
        super(CollidableOffset, self).__init__(**kwargs)
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        collidable  = kwargs.pop("collidable", None)
        self.__collidable = collidable
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        rotation  = kwargs.pop("rotation", [0, 0, 1, 0])
        self.__rotation = rotation
        translation  = kwargs.pop("translation", [0, 0, 0])
        self.__translation = translation
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def rotation(self):
        return self.__rotation
    @rotation.setter
    def rotation(self, value = [0, 0, 1, 0]):
        self.__rotation = [value]
    def setRotation(self, rotation = [0, 0, 1, 0]):
        self.__rotation = [rotation]
        return self
    def addRotation(self, rotation = [0, 0, 1, 0]):
        if self.__rotation == None:            self.__rotation =  []
        self.__rotation +=  [rotation]
        return self
    def removeRotation(self, rotation):
        self.__rotation = [x for x in self.__rotation if x not in rotation]
        return self.__rotation
    def getRotation(self, rotation = [0, 0, 1, 0]):
        return self.__rotation
    def rotation_changed(self, rotation = [0, 0, 1, 0]):
        return self.__rotation
    @property
    def translation(self):
        return self.__translation
    @translation.setter
    def translation(self, value = [0, 0, 0]):
        self.__translation = [value]
    def setTranslation(self, translation = [0, 0, 0]):
        self.__translation = [translation]
        return self
    def addTranslation(self, translation = [0, 0, 0]):
        if self.__translation == None:            self.__translation =  []
        self.__translation +=  [translation]
        return self
    def removeTranslation(self, translation):
        self.__translation = [x for x in self.__translation if x not in translation]
        return self.__translation
    def getTranslation(self, translation = [0, 0, 0]):
        return self.__translation
    def translation_changed(self, translation = [0, 0, 0]):
        return self.__translation
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<CollidableOffset'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__rotation is not None:
            if isinstance(self.__rotation, six.string_types):
                str += ' rotation="'+self.__rotation+'"'
            else:
                str += ' rotation="'+self.__rotation[0]+'"'
        if self.__translation is not None:
            if isinstance(self.__translation, six.string_types):
                str += ' translation="'+self.__translation+'"'
            else:
                str += ' translation="'+self.__translation[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<collidable'
        if self.__collidable is not None:
           for s in self.__collidable:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__collidable is not None:
           for s in self.__collidable:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</collidable>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</CollidableOffset>'
        return str


class CollidableShape(X3DNBodyCollidableNode):
    def __init__(self, **kwargs):
        super(CollidableShape, self).__init__(**kwargs)
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        rotation  = kwargs.pop("rotation", [0, 0, 1, 0])
        self.__rotation = rotation
        shape  = kwargs.pop("shape", None)
        self.__shape = shape
        translation  = kwargs.pop("translation", [0, 0, 0])
        self.__translation = translation
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def rotation(self):
        return self.__rotation
    @rotation.setter
    def rotation(self, value = [0, 0, 1, 0]):
        self.__rotation = [value]
    def setRotation(self, rotation = [0, 0, 1, 0]):
        self.__rotation = [rotation]
        return self
    def addRotation(self, rotation = [0, 0, 1, 0]):
        if self.__rotation == None:            self.__rotation =  []
        self.__rotation +=  [rotation]
        return self
    def removeRotation(self, rotation):
        self.__rotation = [x for x in self.__rotation if x not in rotation]
        return self.__rotation
    def getRotation(self, rotation = [0, 0, 1, 0]):
        return self.__rotation
    def rotation_changed(self, rotation = [0, 0, 1, 0]):
        return self.__rotation
    @property
    def translation(self):
        return self.__translation
    @translation.setter
    def translation(self, value = [0, 0, 0]):
        self.__translation = [value]
    def setTranslation(self, translation = [0, 0, 0]):
        self.__translation = [translation]
        return self
    def addTranslation(self, translation = [0, 0, 0]):
        if self.__translation == None:            self.__translation =  []
        self.__translation +=  [translation]
        return self
    def removeTranslation(self, translation):
        self.__translation = [x for x in self.__translation if x not in translation]
        return self.__translation
    def getTranslation(self, translation = [0, 0, 0]):
        return self.__translation
    def translation_changed(self, translation = [0, 0, 0]):
        return self.__translation
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<CollidableShape'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__rotation is not None:
            if isinstance(self.__rotation, six.string_types):
                str += ' rotation="'+self.__rotation+'"'
            else:
                str += ' rotation="'+self.__rotation[0]+'"'
        if self.__translation is not None:
            if isinstance(self.__translation, six.string_types):
                str += ' translation="'+self.__translation+'"'
            else:
                str += ' translation="'+self.__translation[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<shape'
        if self.__shape is not None:
           for s in self.__shape:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__shape is not None:
           for s in self.__shape:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</shape>'
        str += '</CollidableShape>'
        return str


class Collision(X3DSensorNode, X3DGroupingNode):
    def __init__(self, **kwargs):
        super(Collision, self).__init__(**kwargs)
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        children  = kwargs.pop("children", None)
        self.__children = children
        collideTime  = kwargs.pop("collideTime", None)
        self.__collideTime = collideTime
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        proxy  = kwargs.pop("proxy", None)
        self.__proxy = proxy
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    def addChildren(self, Children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [Children]
        return self
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    def removeCollideTime(self, collideTime):
        self.__collideTime = [x for x in self.__collideTime if x not in collideTime]
        return self.__collideTime
    def getCollideTime(self, collideTime = None):
        return self.__collideTime
    def collideTime_changed(self, collideTime = None):
        return self.__collideTime
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    def isActive(self, Active = None):
        return self.__Active
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    @property
    def proxy(self):
        return self.__proxy
    @proxy.setter
    def proxy(self, value = None):
        self.__proxy = [value]
    def setProxy(self, proxy = None):
        self.__proxy = [proxy]
        return self
    def addProxy(self, proxy = None):
        if self.__proxy == None:            self.__proxy =  []
        self.__proxy +=  [proxy]
        return self
    def toXML(self):
        str = ''
        str += '<Collision'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__collideTime is not None:
            if isinstance(self.__collideTime, six.string_types):
                str += ' collideTime="'+self.__collideTime+'"'
            else:
                str += ' collideTime="'+self.__collideTime[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<proxy'
        if self.__proxy is not None:
           for s in self.__proxy:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__proxy is not None:
           for s in self.__proxy:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</proxy>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '</Collision>'
        return str


class CollisionCollection(X3DNode):
    def __init__(self, **kwargs):
        super(CollisionCollection, self).__init__(**kwargs)
        appliedParameters  = kwargs.pop("appliedParameters", ["BOUNCE"])
        if '"BOUNCE"' == appliedParameters:
            pass
        elif '"USER_FRICTION"' == appliedParameters:
            pass
        elif '"FRICTION_COEFFICIENT-2"' == appliedParameters:
            pass
        elif '"ERROR_REDUCTION"' == appliedParameters:
            pass
        elif '"CONSTANT_FORCE"' == appliedParameters:
            pass
        elif '"SPEED-1"' == appliedParameters:
            pass
        elif '"SPEED-2"' == appliedParameters:
            pass
        elif '"SLIP-1"' == appliedParameters:
            pass
        elif '"SLIP-2"' == appliedParameters:
            pass
        else:
            return None
        self.__appliedParameters = appliedParameters
        bounce  = kwargs.pop("bounce", 0)
        if bounce == None or bounce  <  0:
            return None
        if bounce == None or bounce  >  1:
            return None
        self.__bounce = bounce
        collidables  = kwargs.pop("collidables", None)
        self.__collidables = collidables
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        frictionCoefficients  = kwargs.pop("frictionCoefficients", [0, 0])
        if frictionCoefficients == None or len(frictionCoefficients) <= 0 or min(frictionCoefficients)  <  0:
            return None
        self.__frictionCoefficients = frictionCoefficients
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        minBounceSpeed  = kwargs.pop("minBounceSpeed", 0.1)
        if minBounceSpeed == None or minBounceSpeed  <  0:
            return None
        self.__minBounceSpeed = minBounceSpeed
        slipFactors  = kwargs.pop("slipFactors", [0, 0])
        self.__slipFactors = slipFactors
        softnessConstantForceMix  = kwargs.pop("softnessConstantForceMix", 0.0001)
        if softnessConstantForceMix == None or softnessConstantForceMix  <  0:
            return None
        if softnessConstantForceMix == None or softnessConstantForceMix  >  1:
            return None
        self.__softnessConstantForceMix = softnessConstantForceMix
        softnessErrorCorrection  = kwargs.pop("softnessErrorCorrection", 0.8)
        if softnessErrorCorrection == None or softnessErrorCorrection  <  0:
            return None
        if softnessErrorCorrection == None or softnessErrorCorrection  >  1:
            return None
        self.__softnessErrorCorrection = softnessErrorCorrection
        surfaceSpeed  = kwargs.pop("surfaceSpeed", [0, 0])
        self.__surfaceSpeed = surfaceSpeed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def appliedParameters(self):
        return self.__appliedParameters
    @appliedParameters.setter
    def appliedParameters(self, value = ["BOUNCE"]):
        if '"BOUNCE"' == value:
            pass
        elif '"USER_FRICTION"' == value:
            pass
        elif '"FRICTION_COEFFICIENT-2"' == value:
            pass
        elif '"ERROR_REDUCTION"' == value:
            pass
        elif '"CONSTANT_FORCE"' == value:
            pass
        elif '"SPEED-1"' == value:
            pass
        elif '"SPEED-2"' == value:
            pass
        elif '"SLIP-1"' == value:
            pass
        elif '"SLIP-2"' == value:
            pass
        else:
            return None
        self.__appliedParameters = [value]
    def setAppliedParameters(self, appliedParameters = ["BOUNCE"]):
        if '"BOUNCE"' == appliedParameters:
            pass
        elif '"USER_FRICTION"' == appliedParameters:
            pass
        elif '"FRICTION_COEFFICIENT-2"' == appliedParameters:
            pass
        elif '"ERROR_REDUCTION"' == appliedParameters:
            pass
        elif '"CONSTANT_FORCE"' == appliedParameters:
            pass
        elif '"SPEED-1"' == appliedParameters:
            pass
        elif '"SPEED-2"' == appliedParameters:
            pass
        elif '"SLIP-1"' == appliedParameters:
            pass
        elif '"SLIP-2"' == appliedParameters:
            pass
        else:
            return None
        self.__appliedParameters = [appliedParameters]
        return self
    def addAppliedParameters(self, appliedParameters = ["BOUNCE"]):
        if '"BOUNCE"' == appliedParameters:
            pass
        elif '"USER_FRICTION"' == appliedParameters:
            pass
        elif '"FRICTION_COEFFICIENT-2"' == appliedParameters:
            pass
        elif '"ERROR_REDUCTION"' == appliedParameters:
            pass
        elif '"CONSTANT_FORCE"' == appliedParameters:
            pass
        elif '"SPEED-1"' == appliedParameters:
            pass
        elif '"SPEED-2"' == appliedParameters:
            pass
        elif '"SLIP-1"' == appliedParameters:
            pass
        elif '"SLIP-2"' == appliedParameters:
            pass
        else:
            return None
        if self.__appliedParameters == None:            self.__appliedParameters =  []
        self.__appliedParameters +=  [appliedParameters]
        return self
    def removeAppliedParameters(self, appliedParameters):
        self.__appliedParameters = [x for x in self.__appliedParameters if x not in appliedParameters]
        return self.__appliedParameters
    def getAppliedParameters(self, appliedParameters = ["BOUNCE"]):
        return self.__appliedParameters
    def appliedParameters_changed(self, appliedParameters = ["BOUNCE"]):
        return self.__appliedParameters
    @property
    def bounce(self):
        return self.__bounce
    @bounce.setter
    def bounce(self, value = 0):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__bounce = [value]
    def setBounce(self, bounce = 0):
        if bounce == None or bounce  <  0:
            return None
        if bounce == None or bounce  >  1:
            return None
        self.__bounce = [bounce]
        return self
    def addBounce(self, bounce = 0):
        if bounce == None or bounce  <  0:
            return None
        if bounce == None or bounce  >  1:
            return None
        if self.__bounce == None:            self.__bounce =  []
        self.__bounce +=  [bounce]
        return self
    def removeBounce(self, bounce):
        self.__bounce = [x for x in self.__bounce if x not in bounce]
        return self.__bounce
    def getBounce(self, bounce = 0):
        return self.__bounce
    def bounce_changed(self, bounce = 0):
        return self.__bounce
    @property
    def collidables(self):
        return self.__collidables
    @collidables.setter
    def collidables(self, value = None):
        self.__collidables = [value]
    def setCollidables(self, collidables = None):
        self.__collidables = [collidables]
        return self
    def addCollidables(self, collidables = None):
        if self.__collidables == None:            self.__collidables =  []
        self.__collidables +=  [collidables]
        return self
    def removeCollidables(self, collidables):
        self.__collidables = [x for x in self.__collidables if x not in collidables]
        return self.__collidables
    def getCollidables(self, collidables = None):
        return self.__collidables
    def collidables_changed(self, collidables = None):
        return self.__collidables
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def frictionCoefficients(self):
        return self.__frictionCoefficients
    @frictionCoefficients.setter
    def frictionCoefficients(self, value = [0, 0]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        self.__frictionCoefficients = [value]
    def setFrictionCoefficients(self, frictionCoefficients = [0, 0]):
        if frictionCoefficients == None or len(frictionCoefficients) <= 0 or min(frictionCoefficients)  <  0:
            return None
        self.__frictionCoefficients = [frictionCoefficients]
        return self
    def addFrictionCoefficients(self, frictionCoefficients = [0, 0]):
        if frictionCoefficients == None or len(frictionCoefficients) <= 0 or min(frictionCoefficients)  <  0:
            return None
        if self.__frictionCoefficients == None:            self.__frictionCoefficients =  []
        self.__frictionCoefficients +=  [frictionCoefficients]
        return self
    def removeFrictionCoefficients(self, frictionCoefficients):
        self.__frictionCoefficients = [x for x in self.__frictionCoefficients if x not in frictionCoefficients]
        return self.__frictionCoefficients
    def getFrictionCoefficients(self, frictionCoefficients = [0, 0]):
        return self.__frictionCoefficients
    def frictionCoefficients_changed(self, frictionCoefficients = [0, 0]):
        return self.__frictionCoefficients
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def minBounceSpeed(self):
        return self.__minBounceSpeed
    @minBounceSpeed.setter
    def minBounceSpeed(self, value = 0.1):
        if value == None or value  <  0:
            return None
        self.__minBounceSpeed = [value]
    def setMinBounceSpeed(self, minBounceSpeed = 0.1):
        if minBounceSpeed == None or minBounceSpeed  <  0:
            return None
        self.__minBounceSpeed = [minBounceSpeed]
        return self
    def addMinBounceSpeed(self, minBounceSpeed = 0.1):
        if minBounceSpeed == None or minBounceSpeed  <  0:
            return None
        if self.__minBounceSpeed == None:            self.__minBounceSpeed =  []
        self.__minBounceSpeed +=  [minBounceSpeed]
        return self
    def removeMinBounceSpeed(self, minBounceSpeed):
        self.__minBounceSpeed = [x for x in self.__minBounceSpeed if x not in minBounceSpeed]
        return self.__minBounceSpeed
    def getMinBounceSpeed(self, minBounceSpeed = 0.1):
        return self.__minBounceSpeed
    def minBounceSpeed_changed(self, minBounceSpeed = 0.1):
        return self.__minBounceSpeed
    @property
    def slipFactors(self):
        return self.__slipFactors
    @slipFactors.setter
    def slipFactors(self, value = [0, 0]):
        self.__slipFactors = [value]
    def setSlipFactors(self, slipFactors = [0, 0]):
        self.__slipFactors = [slipFactors]
        return self
    def addSlipFactors(self, slipFactors = [0, 0]):
        if self.__slipFactors == None:            self.__slipFactors =  []
        self.__slipFactors +=  [slipFactors]
        return self
    def removeSlipFactors(self, slipFactors):
        self.__slipFactors = [x for x in self.__slipFactors if x not in slipFactors]
        return self.__slipFactors
    def getSlipFactors(self, slipFactors = [0, 0]):
        return self.__slipFactors
    def slipFactors_changed(self, slipFactors = [0, 0]):
        return self.__slipFactors
    @property
    def softnessConstantForceMix(self):
        return self.__softnessConstantForceMix
    @softnessConstantForceMix.setter
    def softnessConstantForceMix(self, value = 0.0001):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__softnessConstantForceMix = [value]
    def setSoftnessConstantForceMix(self, softnessConstantForceMix = 0.0001):
        if softnessConstantForceMix == None or softnessConstantForceMix  <  0:
            return None
        if softnessConstantForceMix == None or softnessConstantForceMix  >  1:
            return None
        self.__softnessConstantForceMix = [softnessConstantForceMix]
        return self
    def addSoftnessConstantForceMix(self, softnessConstantForceMix = 0.0001):
        if softnessConstantForceMix == None or softnessConstantForceMix  <  0:
            return None
        if softnessConstantForceMix == None or softnessConstantForceMix  >  1:
            return None
        if self.__softnessConstantForceMix == None:            self.__softnessConstantForceMix =  []
        self.__softnessConstantForceMix +=  [softnessConstantForceMix]
        return self
    def removeSoftnessConstantForceMix(self, softnessConstantForceMix):
        self.__softnessConstantForceMix = [x for x in self.__softnessConstantForceMix if x not in softnessConstantForceMix]
        return self.__softnessConstantForceMix
    def getSoftnessConstantForceMix(self, softnessConstantForceMix = 0.0001):
        return self.__softnessConstantForceMix
    def softnessConstantForceMix_changed(self, softnessConstantForceMix = 0.0001):
        return self.__softnessConstantForceMix
    @property
    def softnessErrorCorrection(self):
        return self.__softnessErrorCorrection
    @softnessErrorCorrection.setter
    def softnessErrorCorrection(self, value = 0.8):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__softnessErrorCorrection = [value]
    def setSoftnessErrorCorrection(self, softnessErrorCorrection = 0.8):
        if softnessErrorCorrection == None or softnessErrorCorrection  <  0:
            return None
        if softnessErrorCorrection == None or softnessErrorCorrection  >  1:
            return None
        self.__softnessErrorCorrection = [softnessErrorCorrection]
        return self
    def addSoftnessErrorCorrection(self, softnessErrorCorrection = 0.8):
        if softnessErrorCorrection == None or softnessErrorCorrection  <  0:
            return None
        if softnessErrorCorrection == None or softnessErrorCorrection  >  1:
            return None
        if self.__softnessErrorCorrection == None:            self.__softnessErrorCorrection =  []
        self.__softnessErrorCorrection +=  [softnessErrorCorrection]
        return self
    def removeSoftnessErrorCorrection(self, softnessErrorCorrection):
        self.__softnessErrorCorrection = [x for x in self.__softnessErrorCorrection if x not in softnessErrorCorrection]
        return self.__softnessErrorCorrection
    def getSoftnessErrorCorrection(self, softnessErrorCorrection = 0.8):
        return self.__softnessErrorCorrection
    def softnessErrorCorrection_changed(self, softnessErrorCorrection = 0.8):
        return self.__softnessErrorCorrection
    @property
    def surfaceSpeed(self):
        return self.__surfaceSpeed
    @surfaceSpeed.setter
    def surfaceSpeed(self, value = [0, 0]):
        self.__surfaceSpeed = [value]
    def setSurfaceSpeed(self, surfaceSpeed = [0, 0]):
        self.__surfaceSpeed = [surfaceSpeed]
        return self
    def addSurfaceSpeed(self, surfaceSpeed = [0, 0]):
        if self.__surfaceSpeed == None:            self.__surfaceSpeed =  []
        self.__surfaceSpeed +=  [surfaceSpeed]
        return self
    def removeSurfaceSpeed(self, surfaceSpeed):
        self.__surfaceSpeed = [x for x in self.__surfaceSpeed if x not in surfaceSpeed]
        return self.__surfaceSpeed
    def getSurfaceSpeed(self, surfaceSpeed = [0, 0]):
        return self.__surfaceSpeed
    def surfaceSpeed_changed(self, surfaceSpeed = [0, 0]):
        return self.__surfaceSpeed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<CollisionCollection'
        if self.__appliedParameters is not None:
            if isinstance(self.__appliedParameters, six.string_types):
                str += ' appliedParameters="'+self.__appliedParameters+'"'
            else:
                str += ' appliedParameters="'+self.__appliedParameters[0]+'"'
        if self.__bounce is not None:
            if isinstance(self.__bounce, six.string_types):
                str += ' bounce="'+self.__bounce+'"'
            else:
                str += ' bounce="'+self.__bounce[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__frictionCoefficients is not None:
            if isinstance(self.__frictionCoefficients, six.string_types):
                str += ' frictionCoefficients="'+self.__frictionCoefficients+'"'
            else:
                str += ' frictionCoefficients="'+self.__frictionCoefficients[0]+'"'
        if self.__minBounceSpeed is not None:
            if isinstance(self.__minBounceSpeed, six.string_types):
                str += ' minBounceSpeed="'+self.__minBounceSpeed+'"'
            else:
                str += ' minBounceSpeed="'+self.__minBounceSpeed[0]+'"'
        if self.__slipFactors is not None:
            if isinstance(self.__slipFactors, six.string_types):
                str += ' slipFactors="'+self.__slipFactors+'"'
            else:
                str += ' slipFactors="'+self.__slipFactors[0]+'"'
        if self.__softnessConstantForceMix is not None:
            if isinstance(self.__softnessConstantForceMix, six.string_types):
                str += ' softnessConstantForceMix="'+self.__softnessConstantForceMix+'"'
            else:
                str += ' softnessConstantForceMix="'+self.__softnessConstantForceMix[0]+'"'
        if self.__softnessErrorCorrection is not None:
            if isinstance(self.__softnessErrorCorrection, six.string_types):
                str += ' softnessErrorCorrection="'+self.__softnessErrorCorrection+'"'
            else:
                str += ' softnessErrorCorrection="'+self.__softnessErrorCorrection[0]+'"'
        if self.__surfaceSpeed is not None:
            if isinstance(self.__surfaceSpeed, six.string_types):
                str += ' surfaceSpeed="'+self.__surfaceSpeed+'"'
            else:
                str += ' surfaceSpeed="'+self.__surfaceSpeed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<collidables'
        if self.__collidables is not None:
           for s in self.__collidables:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__collidables is not None:
           for s in self.__collidables:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</collidables>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</CollisionCollection>'
        return str


class CollisionSensor(X3DSensorNode):
    def __init__(self, **kwargs):
        super(CollisionSensor, self).__init__(**kwargs)
        collider  = kwargs.pop("collider", None)
        self.__collider = collider
        contacts  = kwargs.pop("contacts", None)
        self.__contacts = contacts
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        intersections  = kwargs.pop("intersections", None)
        self.__intersections = intersections
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def collider(self):
        return self.__collider
    @collider.setter
    def collider(self, value = None):
        self.__collider = [value]
    def setCollider(self, collider = None):
        self.__collider = [collider]
        return self
    def addCollider(self, collider = None):
        if self.__collider == None:            self.__collider =  []
        self.__collider +=  [collider]
        return self
    def removeCollider(self, collider):
        self.__collider = [x for x in self.__collider if x not in collider]
        return self.__collider
    def getCollider(self, collider = None):
        return self.__collider
    def collider_changed(self, collider = None):
        return self.__collider
    def removeContacts(self, contacts):
        self.__contacts = [x for x in self.__contacts if x not in contacts]
        return self.__contacts
    def getContacts(self, contacts = None):
        return self.__contacts
    def contacts_changed(self, contacts = None):
        return self.__contacts
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    def removeIntersections(self, intersections):
        self.__intersections = [x for x in self.__intersections if x not in intersections]
        return self.__intersections
    def getIntersections(self, intersections = None):
        return self.__intersections
    def intersections_changed(self, intersections = None):
        return self.__intersections
    def isActive(self, Active = None):
        return self.__Active
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<CollisionSensor'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<collider'
        if self.__collider is not None:
           for s in self.__collider:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__collider is not None:
           for s in self.__collider:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</collider>'
        str += '<contacts'
        if self.__contacts is not None:
           for s in self.__contacts:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__contacts is not None:
           for s in self.__contacts:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</contacts>'
        str += '<intersections'
        if self.__intersections is not None:
           for s in self.__intersections:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__intersections is not None:
           for s in self.__intersections:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</intersections>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</CollisionSensor>'
        return str


class CollisionSpace(X3DNBodyCollisionSpaceNode):
    def __init__(self, **kwargs):
        super(CollisionSpace, self).__init__(**kwargs)
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        collidables  = kwargs.pop("collidables", None)
        self.__collidables = collidables
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        useGeometry  = kwargs.pop("useGeometry", False)
        self.__useGeometry = useGeometry
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def collidables(self):
        return self.__collidables
    @collidables.setter
    def collidables(self, value = None):
        self.__collidables = [value]
    def setCollidables(self, collidables = None):
        self.__collidables = [collidables]
        return self
    def addCollidables(self, collidables = None):
        if self.__collidables == None:            self.__collidables =  []
        self.__collidables +=  [collidables]
        return self
    def removeCollidables(self, collidables):
        self.__collidables = [x for x in self.__collidables if x not in collidables]
        return self.__collidables
    def getCollidables(self, collidables = None):
        return self.__collidables
    def collidables_changed(self, collidables = None):
        return self.__collidables
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def useGeometry(self):
        return self.__useGeometry
    @useGeometry.setter
    def useGeometry(self, value = False):
        self.__useGeometry = [value]
    def setUseGeometry(self, useGeometry = False):
        self.__useGeometry = [useGeometry]
        return self
    def addUseGeometry(self, useGeometry = False):
        if self.__useGeometry == None:            self.__useGeometry =  []
        self.__useGeometry +=  [useGeometry]
        return self
    def removeUseGeometry(self, useGeometry):
        self.__useGeometry = [x for x in self.__useGeometry if x not in useGeometry]
        return self.__useGeometry
    def isUseGeometry(self, useGeometry = False):
        return self.__useGeometry
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<CollisionSpace'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__useGeometry is not None:
            if isinstance(self.__useGeometry, six.string_types):
                str += ' useGeometry="'+self.__useGeometry+'"'
            else:
                str += ' useGeometry="'+self.__useGeometry[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<collidables'
        if self.__collidables is not None:
           for s in self.__collidables:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__collidables is not None:
           for s in self.__collidables:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</collidables>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</CollisionSpace>'
        return str


class Color(X3DColorNode):
    def __init__(self, **kwargs):
        super(Color, self).__init__(**kwargs)
        color  = kwargs.pop("color", None)
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        self.__color = color
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def color(self):
        return self.__color
    @color.setter
    def color(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__color = [value]
    def setColor(self, color = None):
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        self.__color = [color]
        return self
    def addColor(self, color = None):
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        if self.__color == None:            self.__color =  []
        self.__color +=  [color]
        return self
    def removeColor(self, color):
        self.__color = [x for x in self.__color if x not in color]
        return self.__color
    def getColor(self, color = None):
        return self.__color
    def color_changed(self, color = None):
        return self.__color
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Color'
        if self.__color is not None:
            if isinstance(self.__color, six.string_types):
                str += ' color="'+self.__color+'"'
            else:
                str += ' color="'+self.__color[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</Color>'
        return str


class ColorChaser(X3DChaserNode):
    def __init__(self, **kwargs):
        super(ColorChaser, self).__init__(**kwargs)
        duration  = kwargs.pop("duration", 1)
        if duration == None or duration  <  0:
            return None
        self.__duration = duration
        initialDestination  = kwargs.pop("initialDestination", [0.8, 0.8, 0.8])
        if initialDestination == None or len(initialDestination) <= 0 or min(initialDestination)  <  0:
            return None
        if initialDestination == None or len(initialDestination) <= 0 or max(initialDestination)  >  1:
            return None
        self.__initialDestination = initialDestination
        initialValue  = kwargs.pop("initialValue", [0.8, 0.8, 0.8])
        if initialValue == None or len(initialValue) <= 0 or min(initialValue)  <  0:
            return None
        if initialValue == None or len(initialValue) <= 0 or max(initialValue)  >  1:
            return None
        self.__initialValue = initialValue
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        destination  = kwargs.pop("destination", None)
        if destination == None or len(destination) <= 0 or min(destination)  <  0:
            return None
        if destination == None or len(destination) <= 0 or max(destination)  >  1:
            return None
        self.__destination = destination
        value  = kwargs.pop("value", None)
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__value = value
        value_changed  = kwargs.pop("value_changed", None)
        if value_changed == None or len(value_changed) <= 0 or min(value_changed)  <  0:
            return None
        if value_changed == None or len(value_changed) <= 0 or max(value_changed)  >  1:
            return None
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def isActive(self, Active = None):
        return self.__Active
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def destination(self):
        return self.__destination
    @destination.setter
    def destination(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__destination = [value]
    def set_destination(self, destination = None):
        if destination == None or len(destination) <= 0 or min(destination)  <  0:
            return None
        if destination == None or len(destination) <= 0 or max(destination)  >  1:
            return None
        self.__destination = [destination]
        return self
    @property
    def value(self):
        return self.__value
    @value.setter
    def value(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__value = [value]
    def set_value(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__value = [value]
        return self
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ColorChaser'
        if self.__duration is not None:
            if isinstance(self.__duration, six.string_types):
                str += ' duration="'+self.__duration+'"'
            else:
                str += ' duration="'+self.__duration[0]+'"'
        if self.__initialDestination is not None:
            if isinstance(self.__initialDestination, six.string_types):
                str += ' initialDestination="'+self.__initialDestination+'"'
            else:
                str += ' initialDestination="'+self.__initialDestination[0]+'"'
        if self.__initialValue is not None:
            if isinstance(self.__initialValue, six.string_types):
                str += ' initialValue="'+self.__initialValue+'"'
            else:
                str += ' initialValue="'+self.__initialValue[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__destination is not None:
            if isinstance(self.__destination, six.string_types):
                str += ' destination="'+self.__destination+'"'
            else:
                str += ' destination="'+self.__destination[0]+'"'
        if self.__value is not None:
            if isinstance(self.__value, six.string_types):
                str += ' value="'+self.__value+'"'
            else:
                str += ' value="'+self.__value[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</ColorChaser>'
        return str


class ColorDamper(X3DDamperNode):
    def __init__(self, **kwargs):
        super(ColorDamper, self).__init__(**kwargs)
        initialDestination  = kwargs.pop("initialDestination", [0.8, 0.8, 0.8])
        if initialDestination == None or len(initialDestination) <= 0 or min(initialDestination)  <  0:
            return None
        if initialDestination == None or len(initialDestination) <= 0 or max(initialDestination)  >  1:
            return None
        self.__initialDestination = initialDestination
        initialValue  = kwargs.pop("initialValue", [0.8, 0.8, 0.8])
        if initialValue == None or len(initialValue) <= 0 or min(initialValue)  <  0:
            return None
        if initialValue == None or len(initialValue) <= 0 or max(initialValue)  >  1:
            return None
        self.__initialValue = initialValue
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        order  = kwargs.pop("order", 3)
        if order == None or order  <  0:
            return None
        if order == None or order  >  5:
            return None
        self.__order = order
        destination  = kwargs.pop("destination", None)
        if destination == None or len(destination) <= 0 or min(destination)  <  0:
            return None
        if destination == None or len(destination) <= 0 or max(destination)  >  1:
            return None
        self.__destination = destination
        value  = kwargs.pop("value", None)
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__value = value
        tau  = kwargs.pop("tau", 0.3)
        if tau == None or tau  <  0:
            return None
        self.__tau = tau
        tolerance  = kwargs.pop("tolerance", -1)
        self.__tolerance = tolerance
        value_changed  = kwargs.pop("value_changed", None)
        if value_changed == None or len(value_changed) <= 0 or min(value_changed)  <  0:
            return None
        if value_changed == None or len(value_changed) <= 0 or max(value_changed)  >  1:
            return None
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def isActive(self, Active = None):
        return self.__Active
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def destination(self):
        return self.__destination
    @destination.setter
    def destination(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__destination = [value]
    def set_destination(self, destination = None):
        if destination == None or len(destination) <= 0 or min(destination)  <  0:
            return None
        if destination == None or len(destination) <= 0 or max(destination)  >  1:
            return None
        self.__destination = [destination]
        return self
    @property
    def value(self):
        return self.__value
    @value.setter
    def value(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__value = [value]
    def set_value(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__value = [value]
        return self
    @property
    def tau(self):
        return self.__tau
    @tau.setter
    def tau(self, value = 0.3):
        if value == None or value  <  0:
            return None
        self.__tau = [value]
    def setTau(self, tau = 0.3):
        if tau == None or tau  <  0:
            return None
        self.__tau = [tau]
        return self
    def addTau(self, tau = 0.3):
        if tau == None or tau  <  0:
            return None
        if self.__tau == None:            self.__tau =  []
        self.__tau +=  [tau]
        return self
    def removeTau(self, tau):
        self.__tau = [x for x in self.__tau if x not in tau]
        return self.__tau
    def getTau(self, tau = 0.3):
        return self.__tau
    def tau_changed(self, tau = 0.3):
        return self.__tau
    @property
    def tolerance(self):
        return self.__tolerance
    @tolerance.setter
    def tolerance(self, value = -1):
        self.__tolerance = [value]
    def setTolerance(self, tolerance = -1):
        self.__tolerance = [tolerance]
        return self
    def addTolerance(self, tolerance = -1):
        if self.__tolerance == None:            self.__tolerance =  []
        self.__tolerance +=  [tolerance]
        return self
    def removeTolerance(self, tolerance):
        self.__tolerance = [x for x in self.__tolerance if x not in tolerance]
        return self.__tolerance
    def getTolerance(self, tolerance = -1):
        return self.__tolerance
    def tolerance_changed(self, tolerance = -1):
        return self.__tolerance
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ColorDamper'
        if self.__initialDestination is not None:
            if isinstance(self.__initialDestination, six.string_types):
                str += ' initialDestination="'+self.__initialDestination+'"'
            else:
                str += ' initialDestination="'+self.__initialDestination[0]+'"'
        if self.__initialValue is not None:
            if isinstance(self.__initialValue, six.string_types):
                str += ' initialValue="'+self.__initialValue+'"'
            else:
                str += ' initialValue="'+self.__initialValue[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__order is not None:
            if isinstance(self.__order, six.string_types):
                str += ' order="'+self.__order+'"'
            else:
                str += ' order="'+self.__order[0]+'"'
        if self.__destination is not None:
            if isinstance(self.__destination, six.string_types):
                str += ' destination="'+self.__destination+'"'
            else:
                str += ' destination="'+self.__destination[0]+'"'
        if self.__value is not None:
            if isinstance(self.__value, six.string_types):
                str += ' value="'+self.__value+'"'
            else:
                str += ' value="'+self.__value[0]+'"'
        if self.__tau is not None:
            if isinstance(self.__tau, six.string_types):
                str += ' tau="'+self.__tau+'"'
            else:
                str += ' tau="'+self.__tau[0]+'"'
        if self.__tolerance is not None:
            if isinstance(self.__tolerance, six.string_types):
                str += ' tolerance="'+self.__tolerance+'"'
            else:
                str += ' tolerance="'+self.__tolerance[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</ColorDamper>'
        return str


class ColorInterpolator(X3DInterpolatorNode):
    def __init__(self, **kwargs):
        super(ColorInterpolator, self).__init__(**kwargs)
        key  = kwargs.pop("key", None)
        self.__key = key
        keyValue  = kwargs.pop("keyValue", None)
        if keyValue == None or len(keyValue) <= 0 or min(keyValue)  <  0:
            return None
        if keyValue == None or len(keyValue) <= 0 or max(keyValue)  >  1:
            return None
        self.__keyValue = keyValue
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        fraction  = kwargs.pop("fraction", None)
        self.__fraction = fraction
        value_changed  = kwargs.pop("value_changed", None)
        if value_changed == None or len(value_changed) <= 0 or min(value_changed)  <  0:
            return None
        if value_changed == None or len(value_changed) <= 0 or max(value_changed)  >  1:
            return None
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def key(self):
        return self.__key
    @key.setter
    def key(self, value = None):
        self.__key = [value]
    def setKey(self, key = None):
        self.__key = [key]
        return self
    def addKey(self, key = None):
        if self.__key == None:            self.__key =  []
        self.__key +=  [key]
        return self
    def removeKey(self, key):
        self.__key = [x for x in self.__key if x not in key]
        return self.__key
    def getKey(self, key = None):
        return self.__key
    def key_changed(self, key = None):
        return self.__key
    @property
    def keyValue(self):
        return self.__keyValue
    @keyValue.setter
    def keyValue(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__keyValue = [value]
    def setKeyValue(self, keyValue = None):
        if keyValue == None or len(keyValue) <= 0 or min(keyValue)  <  0:
            return None
        if keyValue == None or len(keyValue) <= 0 or max(keyValue)  >  1:
            return None
        self.__keyValue = [keyValue]
        return self
    def addKeyValue(self, keyValue = None):
        if keyValue == None or len(keyValue) <= 0 or min(keyValue)  <  0:
            return None
        if keyValue == None or len(keyValue) <= 0 or max(keyValue)  >  1:
            return None
        if self.__keyValue == None:            self.__keyValue =  []
        self.__keyValue +=  [keyValue]
        return self
    def removeKeyValue(self, keyValue):
        self.__keyValue = [x for x in self.__keyValue if x not in keyValue]
        return self.__keyValue
    def getKeyValue(self, keyValue = None):
        return self.__keyValue
    def keyValue_changed(self, keyValue = None):
        return self.__keyValue
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def fraction(self):
        return self.__fraction
    @fraction.setter
    def fraction(self, value = None):
        self.__fraction = [value]
    def set_fraction(self, fraction = None):
        self.__fraction = [fraction]
        return self
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ColorInterpolator'
        if self.__key is not None:
            if isinstance(self.__key, six.string_types):
                str += ' key="'+self.__key+'"'
            else:
                str += ' key="'+self.__key[0]+'"'
        if self.__keyValue is not None:
            if isinstance(self.__keyValue, six.string_types):
                str += ' keyValue="'+self.__keyValue+'"'
            else:
                str += ' keyValue="'+self.__keyValue[0]+'"'
        if self.__fraction is not None:
            if isinstance(self.__fraction, six.string_types):
                str += ' fraction="'+self.__fraction+'"'
            else:
                str += ' fraction="'+self.__fraction[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</ColorInterpolator>'
        return str


class ColorRGBA(X3DColorNode):
    def __init__(self, **kwargs):
        super(ColorRGBA, self).__init__(**kwargs)
        color  = kwargs.pop("color", None)
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        self.__color = color
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def color(self):
        return self.__color
    @color.setter
    def color(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__color = [value]
    def setColor(self, color = None):
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        self.__color = [color]
        return self
    def addColor(self, color = None):
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        if self.__color == None:            self.__color =  []
        self.__color +=  [color]
        return self
    def removeColor(self, color):
        self.__color = [x for x in self.__color if x not in color]
        return self.__color
    def getColor(self, color = None):
        return self.__color
    def color_changed(self, color = None):
        return self.__color
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ColorRGBA'
        if self.__color is not None:
            if isinstance(self.__color, six.string_types):
                str += ' color="'+self.__color+'"'
            else:
                str += ' color="'+self.__color[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</ColorRGBA>'
        return str


class ComposedCubeMapTexture(X3DEnvironmentTextureNode):
    def __init__(self, **kwargs):
        super(ComposedCubeMapTexture, self).__init__(**kwargs)
        back  = kwargs.pop("back", None)
        self.__back = back
        bottom  = kwargs.pop("bottom", None)
        self.__bottom = bottom
        front  = kwargs.pop("front", None)
        self.__front = front
        left  = kwargs.pop("left", None)
        self.__left = left
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        right  = kwargs.pop("right", None)
        self.__right = right
        top  = kwargs.pop("top", None)
        self.__top = top
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def back(self):
        return self.__back
    @back.setter
    def back(self, value = None):
        self.__back = [value]
    def setBack(self, back = None):
        self.__back = [back]
        return self
    def addBack(self, back = None):
        if self.__back == None:            self.__back =  []
        self.__back +=  [back]
        return self
    def removeBack(self, back):
        self.__back = [x for x in self.__back if x not in back]
        return self.__back
    def getBack(self, back = None):
        return self.__back
    def back_changed(self, back = None):
        return self.__back
    @property
    def bottom(self):
        return self.__bottom
    @bottom.setter
    def bottom(self, value = None):
        self.__bottom = [value]
    def setBottom(self, bottom = None):
        self.__bottom = [bottom]
        return self
    def addBottom(self, bottom = None):
        if self.__bottom == None:            self.__bottom =  []
        self.__bottom +=  [bottom]
        return self
    def removeBottom(self, bottom):
        self.__bottom = [x for x in self.__bottom if x not in bottom]
        return self.__bottom
    def getBottom(self, bottom = None):
        return self.__bottom
    def bottom_changed(self, bottom = None):
        return self.__bottom
    @property
    def front(self):
        return self.__front
    @front.setter
    def front(self, value = None):
        self.__front = [value]
    def setFront(self, front = None):
        self.__front = [front]
        return self
    def addFront(self, front = None):
        if self.__front == None:            self.__front =  []
        self.__front +=  [front]
        return self
    def removeFront(self, front):
        self.__front = [x for x in self.__front if x not in front]
        return self.__front
    def getFront(self, front = None):
        return self.__front
    def front_changed(self, front = None):
        return self.__front
    @property
    def left(self):
        return self.__left
    @left.setter
    def left(self, value = None):
        self.__left = [value]
    def setLeft(self, left = None):
        self.__left = [left]
        return self
    def addLeft(self, left = None):
        if self.__left == None:            self.__left =  []
        self.__left +=  [left]
        return self
    def removeLeft(self, left):
        self.__left = [x for x in self.__left if x not in left]
        return self.__left
    def getLeft(self, left = None):
        return self.__left
    def left_changed(self, left = None):
        return self.__left
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def right(self):
        return self.__right
    @right.setter
    def right(self, value = None):
        self.__right = [value]
    def setRight(self, right = None):
        self.__right = [right]
        return self
    def addRight(self, right = None):
        if self.__right == None:            self.__right =  []
        self.__right +=  [right]
        return self
    def removeRight(self, right):
        self.__right = [x for x in self.__right if x not in right]
        return self.__right
    def getRight(self, right = None):
        return self.__right
    def right_changed(self, right = None):
        return self.__right
    @property
    def top(self):
        return self.__top
    @top.setter
    def top(self, value = None):
        self.__top = [value]
    def setTop(self, top = None):
        self.__top = [top]
        return self
    def addTop(self, top = None):
        if self.__top == None:            self.__top =  []
        self.__top +=  [top]
        return self
    def removeTop(self, top):
        self.__top = [x for x in self.__top if x not in top]
        return self.__top
    def getTop(self, top = None):
        return self.__top
    def top_changed(self, top = None):
        return self.__top
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ComposedCubeMapTexture'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<back'
        if self.__back is not None:
           for s in self.__back:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__back is not None:
           for s in self.__back:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</back>'
        str += '<bottom'
        if self.__bottom is not None:
           for s in self.__bottom:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__bottom is not None:
           for s in self.__bottom:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</bottom>'
        str += '<front'
        if self.__front is not None:
           for s in self.__front:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__front is not None:
           for s in self.__front:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</front>'
        str += '<left'
        if self.__left is not None:
           for s in self.__left:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__left is not None:
           for s in self.__left:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</left>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<right'
        if self.__right is not None:
           for s in self.__right:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__right is not None:
           for s in self.__right:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</right>'
        str += '<top'
        if self.__top is not None:
           for s in self.__top:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__top is not None:
           for s in self.__top:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</top>'
        str += '</ComposedCubeMapTexture>'
        return str


class ComposedShader(X3DProgrammableShaderObject, X3DShaderNode):
    def __init__(self, **kwargs):
        super(ComposedShader, self).__init__(**kwargs)
        activate  = kwargs.pop("activate", None)
        self.__activate = activate
        Selected  = kwargs.pop("Selected", None)
        self.__Selected = Selected
        Valid  = kwargs.pop("Valid", None)
        self.__Valid = Valid
        language  = kwargs.pop("language", None)
        self.__language = language
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        parts  = kwargs.pop("parts", None)
        self.__parts = parts
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
        field  = kwargs.pop("field", None)
        self.__field = field
    @property
    def activate(self):
        return self.__activate
    @activate.setter
    def activate(self, value = None):
        self.__activate = [value]
    def setActivate(self, activate = None):
        self.__activate = [activate]
        return self
    def addActivate(self, activate = None):
        if self.__activate == None:            self.__activate =  []
        self.__activate +=  [activate]
        return self
    def isSelected(self, Selected = None):
        return self.__Selected
    def isValid(self, Valid = None):
        return self.__Valid
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def parts(self):
        return self.__parts
    @parts.setter
    def parts(self, value = None):
        self.__parts = [value]
    def setParts(self, parts = None):
        self.__parts = [parts]
        return self
    def addParts(self, parts = None):
        if self.__parts == None:            self.__parts =  []
        self.__parts +=  [parts]
        return self
    def removeParts(self, parts):
        self.__parts = [x for x in self.__parts if x not in parts]
        return self.__parts
    def getParts(self, parts = None):
        return self.__parts
    def parts_changed(self, parts = None):
        return self.__parts
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    @property
    def sourceCode(self):
        return self.__sourceCode
    @sourceCode.setter
    def sourceCode(self, value = None):
        self.__sourceCode = [value]
    def setSourceCode(self, sourceCode = None):
        self.__sourceCode = [sourceCode]
        return self
    def addSourceCode(self, sourceCode = None):
        if self.__sourceCode == None:            self.__sourceCode =  []
        self.__sourceCode +=  [sourceCode]
        return self
    @property
    def field(self):
        return self.__field
    @field.setter
    def field(self, value = None):
        self.__field = [value]
    def setField(self, field = None):
        self.__field = [field]
        return self
    def addField(self, field = None):
        if self.__field == None:            self.__field =  []
        self.__field +=  [field]
        return self
    def removeField(self, field):
        self.__field = [x for x in self.__field if x not in field]
        return self.__field
    def getField(self, field = None):
        return self.__field
    def field_changed(self, field = None):
        return self.__field
    def toXML(self):
        str = ''
        str += '<ComposedShader'
        if self.__activate is not None:
            if isinstance(self.__activate, six.string_types):
                str += ' activate="'+self.__activate+'"'
            else:
                str += ' activate="'+self.__activate[0]+'"'
        if self.__Selected is not None:
            if isinstance(self.__Selected, six.string_types):
                str += ' Selected="'+self.__Selected+'"'
            else:
                str += ' Selected="'+self.__Selected[0]+'"'
        if self.__Valid is not None:
            if isinstance(self.__Valid, six.string_types):
                str += ' Valid="'+self.__Valid+'"'
            else:
                str += ' Valid="'+self.__Valid[0]+'"'
        if self.__language is not None:
            if isinstance(self.__language, six.string_types):
                str += ' language="'+self.__language+'"'
            else:
                str += ' language="'+self.__language[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<parts'
        if self.__parts is not None:
           for s in self.__parts:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__parts is not None:
           for s in self.__parts:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</parts>'
        str += '</ComposedShader>'
        return str


class ComposedTexture3D(X3DTexture3DNode):
    def __init__(self, **kwargs):
        super(ComposedTexture3D, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        repeatR  = kwargs.pop("repeatR", False)
        self.__repeatR = repeatR
        repeatS  = kwargs.pop("repeatS", False)
        self.__repeatS = repeatS
        repeatT  = kwargs.pop("repeatT", False)
        self.__repeatT = repeatT
        texture  = kwargs.pop("texture", None)
        self.__texture = texture
        textureProperties  = kwargs.pop("textureProperties", None)
        self.__textureProperties = textureProperties
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def texture(self):
        return self.__texture
    @texture.setter
    def texture(self, value = None):
        self.__texture = [value]
    def setTexture(self, texture = None):
        self.__texture = [texture]
        return self
    def addTexture(self, texture = None):
        if self.__texture == None:            self.__texture =  []
        self.__texture +=  [texture]
        return self
    def removeTexture(self, texture):
        self.__texture = [x for x in self.__texture if x not in texture]
        return self.__texture
    def getTexture(self, texture = None):
        return self.__texture
    def texture_changed(self, texture = None):
        return self.__texture
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ComposedTexture3D'
        if self.__repeatR is not None:
            if isinstance(self.__repeatR, six.string_types):
                str += ' repeatR="'+self.__repeatR+'"'
            else:
                str += ' repeatR="'+self.__repeatR[0]+'"'
        if self.__repeatS is not None:
            if isinstance(self.__repeatS, six.string_types):
                str += ' repeatS="'+self.__repeatS+'"'
            else:
                str += ' repeatS="'+self.__repeatS[0]+'"'
        if self.__repeatT is not None:
            if isinstance(self.__repeatT, six.string_types):
                str += ' repeatT="'+self.__repeatT+'"'
            else:
                str += ' repeatT="'+self.__repeatT[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<texture'
        if self.__texture is not None:
           for s in self.__texture:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__texture is not None:
           for s in self.__texture:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</texture>'
        str += '<textureProperties'
        if self.__textureProperties is not None:
           for s in self.__textureProperties:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__textureProperties is not None:
           for s in self.__textureProperties:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</textureProperties>'
        str += '</ComposedTexture3D>'
        return str


class ComposedVolumeStyle(X3DComposableVolumeRenderStyleNode):
    def __init__(self, **kwargs):
        super(ComposedVolumeStyle, self).__init__(**kwargs)
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        renderStyle  = kwargs.pop("renderStyle", None)
        self.__renderStyle = renderStyle
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def renderStyle(self):
        return self.__renderStyle
    @renderStyle.setter
    def renderStyle(self, value = None):
        self.__renderStyle = [value]
    def setRenderStyle(self, renderStyle = None):
        self.__renderStyle = [renderStyle]
        return self
    def addRenderStyle(self, renderStyle = None):
        if self.__renderStyle == None:            self.__renderStyle =  []
        self.__renderStyle +=  [renderStyle]
        return self
    def removeRenderStyle(self, renderStyle):
        self.__renderStyle = [x for x in self.__renderStyle if x not in renderStyle]
        return self.__renderStyle
    def getRenderStyle(self, renderStyle = None):
        return self.__renderStyle
    def renderStyle_changed(self, renderStyle = None):
        return self.__renderStyle
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ComposedVolumeStyle'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<renderStyle'
        if self.__renderStyle is not None:
           for s in self.__renderStyle:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__renderStyle is not None:
           for s in self.__renderStyle:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</renderStyle>'
        str += '</ComposedVolumeStyle>'
        return str


class Cone(X3DGeometryNode):
    def __init__(self, **kwargs):
        super(Cone, self).__init__(**kwargs)
        bottom  = kwargs.pop("bottom", True)
        self.__bottom = bottom
        bottomRadius  = kwargs.pop("bottomRadius", 1)
        if bottomRadius == None or bottomRadius  <=  0:
            return None
        self.__bottomRadius = bottomRadius
        height  = kwargs.pop("height", 2)
        if height == None or height  <=  0:
            return None
        self.__height = height
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        side  = kwargs.pop("side", True)
        self.__side = side
        solid  = kwargs.pop("solid", True)
        self.__solid = solid
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Cone'
        if self.__bottom is not None:
            if isinstance(self.__bottom, six.string_types):
                str += ' bottom="'+self.__bottom+'"'
            else:
                str += ' bottom="'+self.__bottom[0]+'"'
        if self.__bottomRadius is not None:
            if isinstance(self.__bottomRadius, six.string_types):
                str += ' bottomRadius="'+self.__bottomRadius+'"'
            else:
                str += ' bottomRadius="'+self.__bottomRadius[0]+'"'
        if self.__height is not None:
            if isinstance(self.__height, six.string_types):
                str += ' height="'+self.__height+'"'
            else:
                str += ' height="'+self.__height[0]+'"'
        if self.__side is not None:
            if isinstance(self.__side, six.string_types):
                str += ' side="'+self.__side+'"'
            else:
                str += ' side="'+self.__side[0]+'"'
        if self.__solid is not None:
            if isinstance(self.__solid, six.string_types):
                str += ' solid="'+self.__solid+'"'
            else:
                str += ' solid="'+self.__solid[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</Cone>'
        return str


class ConeEmitter(X3DParticleEmitterNode):
    def __init__(self, **kwargs):
        super(ConeEmitter, self).__init__(**kwargs)
        angle  = kwargs.pop("angle", 0.7854)
        if angle == None or angle  <  0:
            return None
        if angle == None or angle  >  3.1416:
            return None
        self.__angle = angle
        direction  = kwargs.pop("direction", [0, 1, 0])
        if direction == None or len(direction) <= 0 or min(direction)  <  -1:
            return None
        if direction == None or len(direction) <= 0 or max(direction)  >  1:
            return None
        self.__direction = direction
        mass  = kwargs.pop("mass", 0)
        if mass == None or mass  <  0:
            return None
        self.__mass = mass
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        position  = kwargs.pop("position", [0, 0, 0])
        self.__position = position
        speed  = kwargs.pop("speed", 0)
        if speed == None or speed  <  0:
            return None
        self.__speed = speed
        surfaceArea  = kwargs.pop("surfaceArea", 0)
        if surfaceArea == None or surfaceArea  <  0:
            return None
        self.__surfaceArea = surfaceArea
        variation  = kwargs.pop("variation", 0.25)
        if variation == None or variation  <  0:
            return None
        self.__variation = variation
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def angle(self):
        return self.__angle
    @angle.setter
    def angle(self, value = 0.7854):
        if value == None or value  <  0:
            return None
        if value == None or value  >  3.1416:
            return None
        self.__angle = [value]
    def setAngle(self, angle = 0.7854):
        if angle == None or angle  <  0:
            return None
        if angle == None or angle  >  3.1416:
            return None
        self.__angle = [angle]
        return self
    def addAngle(self, angle = 0.7854):
        if angle == None or angle  <  0:
            return None
        if angle == None or angle  >  3.1416:
            return None
        if self.__angle == None:            self.__angle =  []
        self.__angle +=  [angle]
        return self
    def removeAngle(self, angle):
        self.__angle = [x for x in self.__angle if x not in angle]
        return self.__angle
    def getAngle(self, angle = 0.7854):
        return self.__angle
    def angle_changed(self, angle = 0.7854):
        return self.__angle
    @property
    def direction(self):
        return self.__direction
    @direction.setter
    def direction(self, value = [0, 1, 0]):
        if value == None or len(value) <= 0 or min(value)  <  -1:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__direction = [value]
    def setDirection(self, direction = [0, 1, 0]):
        if direction == None or len(direction) <= 0 or min(direction)  <  -1:
            return None
        if direction == None or len(direction) <= 0 or max(direction)  >  1:
            return None
        self.__direction = [direction]
        return self
    def addDirection(self, direction = [0, 1, 0]):
        if direction == None or len(direction) <= 0 or min(direction)  <  -1:
            return None
        if direction == None or len(direction) <= 0 or max(direction)  >  1:
            return None
        if self.__direction == None:            self.__direction =  []
        self.__direction +=  [direction]
        return self
    def removeDirection(self, direction):
        self.__direction = [x for x in self.__direction if x not in direction]
        return self.__direction
    def getDirection(self, direction = [0, 1, 0]):
        return self.__direction
    def direction_changed(self, direction = [0, 1, 0]):
        return self.__direction
    @property
    def mass(self):
        return self.__mass
    @mass.setter
    def mass(self, value = 0):
        if value == None or value  <  0:
            return None
        self.__mass = [value]
    def setMass(self, mass = 0):
        if mass == None or mass  <  0:
            return None
        self.__mass = [mass]
        return self
    def addMass(self, mass = 0):
        if mass == None or mass  <  0:
            return None
        if self.__mass == None:            self.__mass =  []
        self.__mass +=  [mass]
        return self
    def removeMass(self, mass):
        self.__mass = [x for x in self.__mass if x not in mass]
        return self.__mass
    def getMass(self, mass = 0):
        return self.__mass
    def mass_changed(self, mass = 0):
        return self.__mass
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def position(self):
        return self.__position
    @position.setter
    def position(self, value = [0, 0, 0]):
        self.__position = [value]
    def setPosition(self, position = [0, 0, 0]):
        self.__position = [position]
        return self
    def addPosition(self, position = [0, 0, 0]):
        if self.__position == None:            self.__position =  []
        self.__position +=  [position]
        return self
    def removePosition(self, position):
        self.__position = [x for x in self.__position if x not in position]
        return self.__position
    def getPosition(self, position = [0, 0, 0]):
        return self.__position
    def position_changed(self, position = [0, 0, 0]):
        return self.__position
    @property
    def speed(self):
        return self.__speed
    @speed.setter
    def speed(self, value = 0):
        if value == None or value  <  0:
            return None
        self.__speed = [value]
    def setSpeed(self, speed = 0):
        if speed == None or speed  <  0:
            return None
        self.__speed = [speed]
        return self
    def addSpeed(self, speed = 0):
        if speed == None or speed  <  0:
            return None
        if self.__speed == None:            self.__speed =  []
        self.__speed +=  [speed]
        return self
    def removeSpeed(self, speed):
        self.__speed = [x for x in self.__speed if x not in speed]
        return self.__speed
    def getSpeed(self, speed = 0):
        return self.__speed
    def speed_changed(self, speed = 0):
        return self.__speed
    @property
    def variation(self):
        return self.__variation
    @variation.setter
    def variation(self, value = 0.25):
        if value == None or value  <  0:
            return None
        self.__variation = [value]
    def setVariation(self, variation = 0.25):
        if variation == None or variation  <  0:
            return None
        self.__variation = [variation]
        return self
    def addVariation(self, variation = 0.25):
        if variation == None or variation  <  0:
            return None
        if self.__variation == None:            self.__variation =  []
        self.__variation +=  [variation]
        return self
    def removeVariation(self, variation):
        self.__variation = [x for x in self.__variation if x not in variation]
        return self.__variation
    def getVariation(self, variation = 0.25):
        return self.__variation
    def variation_changed(self, variation = 0.25):
        return self.__variation
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ConeEmitter'
        if self.__angle is not None:
            if isinstance(self.__angle, six.string_types):
                str += ' angle="'+self.__angle+'"'
            else:
                str += ' angle="'+self.__angle[0]+'"'
        if self.__direction is not None:
            if isinstance(self.__direction, six.string_types):
                str += ' direction="'+self.__direction+'"'
            else:
                str += ' direction="'+self.__direction[0]+'"'
        if self.__mass is not None:
            if isinstance(self.__mass, six.string_types):
                str += ' mass="'+self.__mass+'"'
            else:
                str += ' mass="'+self.__mass[0]+'"'
        if self.__position is not None:
            if isinstance(self.__position, six.string_types):
                str += ' position="'+self.__position+'"'
            else:
                str += ' position="'+self.__position[0]+'"'
        if self.__speed is not None:
            if isinstance(self.__speed, six.string_types):
                str += ' speed="'+self.__speed+'"'
            else:
                str += ' speed="'+self.__speed[0]+'"'
        if self.__surfaceArea is not None:
            if isinstance(self.__surfaceArea, six.string_types):
                str += ' surfaceArea="'+self.__surfaceArea+'"'
            else:
                str += ' surfaceArea="'+self.__surfaceArea[0]+'"'
        if self.__variation is not None:
            if isinstance(self.__variation, six.string_types):
                str += ' variation="'+self.__variation+'"'
            else:
                str += ' variation="'+self.__variation[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</ConeEmitter>'
        return str


class Contact(X3DNode):
    def __init__(self, **kwargs):
        super(Contact, self).__init__(**kwargs)
        appliedParameters  = kwargs.pop("appliedParameters", ["BOUNCE"])
        if '"BOUNCE"' == appliedParameters:
            pass
        elif '"USER_FRICTION"' == appliedParameters:
            pass
        elif '"FRICTION_COEFFICIENT-2"' == appliedParameters:
            pass
        elif '"ERROR_REDUCTION"' == appliedParameters:
            pass
        elif '"CONSTANT_FORCE"' == appliedParameters:
            pass
        elif '"SPEED-1"' == appliedParameters:
            pass
        elif '"SPEED-2"' == appliedParameters:
            pass
        elif '"SLIP-1"' == appliedParameters:
            pass
        elif '"SLIP-2"' == appliedParameters:
            pass
        else:
            return None
        self.__appliedParameters = appliedParameters
        body1  = kwargs.pop("body1", None)
        self.__body1 = body1
        body2  = kwargs.pop("body2", None)
        self.__body2 = body2
        bounce  = kwargs.pop("bounce", 0)
        if bounce == None or bounce  <  0:
            return None
        if bounce == None or bounce  >  1:
            return None
        self.__bounce = bounce
        contactNormal  = kwargs.pop("contactNormal", [0, 1, 0])
        self.__contactNormal = contactNormal
        depth  = kwargs.pop("depth", 0)
        self.__depth = depth
        frictionCoefficients  = kwargs.pop("frictionCoefficients", [0, 0])
        if frictionCoefficients == None or len(frictionCoefficients) <= 0 or min(frictionCoefficients)  <  0:
            return None
        self.__frictionCoefficients = frictionCoefficients
        frictionDirection  = kwargs.pop("frictionDirection", [0, 1, 0])
        self.__frictionDirection = frictionDirection
        geometry1  = kwargs.pop("geometry1", None)
        self.__geometry1 = geometry1
        geometry2  = kwargs.pop("geometry2", None)
        self.__geometry2 = geometry2
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        minBounceSpeed  = kwargs.pop("minBounceSpeed", 0)
        if minBounceSpeed == None or minBounceSpeed  <  0:
            return None
        self.__minBounceSpeed = minBounceSpeed
        position  = kwargs.pop("position", [0, 0, 0])
        self.__position = position
        slipCoefficients  = kwargs.pop("slipCoefficients", [0, 0])
        self.__slipCoefficients = slipCoefficients
        softnessConstantForceMix  = kwargs.pop("softnessConstantForceMix", 0.0001)
        if softnessConstantForceMix == None or softnessConstantForceMix  <  0:
            return None
        if softnessConstantForceMix == None or softnessConstantForceMix  >  1:
            return None
        self.__softnessConstantForceMix = softnessConstantForceMix
        softnessErrorCorrection  = kwargs.pop("softnessErrorCorrection", 0.8)
        if softnessErrorCorrection == None or softnessErrorCorrection  <  0:
            return None
        if softnessErrorCorrection == None or softnessErrorCorrection  >  1:
            return None
        self.__softnessErrorCorrection = softnessErrorCorrection
        surfaceSpeed  = kwargs.pop("surfaceSpeed", [0, 0])
        self.__surfaceSpeed = surfaceSpeed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def appliedParameters(self):
        return self.__appliedParameters
    @appliedParameters.setter
    def appliedParameters(self, value = ["BOUNCE"]):
        if '"BOUNCE"' == value:
            pass
        elif '"USER_FRICTION"' == value:
            pass
        elif '"FRICTION_COEFFICIENT-2"' == value:
            pass
        elif '"ERROR_REDUCTION"' == value:
            pass
        elif '"CONSTANT_FORCE"' == value:
            pass
        elif '"SPEED-1"' == value:
            pass
        elif '"SPEED-2"' == value:
            pass
        elif '"SLIP-1"' == value:
            pass
        elif '"SLIP-2"' == value:
            pass
        else:
            return None
        self.__appliedParameters = [value]
    def setAppliedParameters(self, appliedParameters = ["BOUNCE"]):
        if '"BOUNCE"' == appliedParameters:
            pass
        elif '"USER_FRICTION"' == appliedParameters:
            pass
        elif '"FRICTION_COEFFICIENT-2"' == appliedParameters:
            pass
        elif '"ERROR_REDUCTION"' == appliedParameters:
            pass
        elif '"CONSTANT_FORCE"' == appliedParameters:
            pass
        elif '"SPEED-1"' == appliedParameters:
            pass
        elif '"SPEED-2"' == appliedParameters:
            pass
        elif '"SLIP-1"' == appliedParameters:
            pass
        elif '"SLIP-2"' == appliedParameters:
            pass
        else:
            return None
        self.__appliedParameters = [appliedParameters]
        return self
    def addAppliedParameters(self, appliedParameters = ["BOUNCE"]):
        if '"BOUNCE"' == appliedParameters:
            pass
        elif '"USER_FRICTION"' == appliedParameters:
            pass
        elif '"FRICTION_COEFFICIENT-2"' == appliedParameters:
            pass
        elif '"ERROR_REDUCTION"' == appliedParameters:
            pass
        elif '"CONSTANT_FORCE"' == appliedParameters:
            pass
        elif '"SPEED-1"' == appliedParameters:
            pass
        elif '"SPEED-2"' == appliedParameters:
            pass
        elif '"SLIP-1"' == appliedParameters:
            pass
        elif '"SLIP-2"' == appliedParameters:
            pass
        else:
            return None
        if self.__appliedParameters == None:            self.__appliedParameters =  []
        self.__appliedParameters +=  [appliedParameters]
        return self
    def removeAppliedParameters(self, appliedParameters):
        self.__appliedParameters = [x for x in self.__appliedParameters if x not in appliedParameters]
        return self.__appliedParameters
    def getAppliedParameters(self, appliedParameters = ["BOUNCE"]):
        return self.__appliedParameters
    def appliedParameters_changed(self, appliedParameters = ["BOUNCE"]):
        return self.__appliedParameters
    @property
    def body1(self):
        return self.__body1
    @body1.setter
    def body1(self, value = None):
        self.__body1 = [value]
    def setBody1(self, body1 = None):
        self.__body1 = [body1]
        return self
    def addBody1(self, body1 = None):
        if self.__body1 == None:            self.__body1 =  []
        self.__body1 +=  [body1]
        return self
    def removeBody1(self, body1):
        self.__body1 = [x for x in self.__body1 if x not in body1]
        return self.__body1
    def getBody1(self, body1 = None):
        return self.__body1
    def body1_changed(self, body1 = None):
        return self.__body1
    @property
    def body2(self):
        return self.__body2
    @body2.setter
    def body2(self, value = None):
        self.__body2 = [value]
    def setBody2(self, body2 = None):
        self.__body2 = [body2]
        return self
    def addBody2(self, body2 = None):
        if self.__body2 == None:            self.__body2 =  []
        self.__body2 +=  [body2]
        return self
    def removeBody2(self, body2):
        self.__body2 = [x for x in self.__body2 if x not in body2]
        return self.__body2
    def getBody2(self, body2 = None):
        return self.__body2
    def body2_changed(self, body2 = None):
        return self.__body2
    @property
    def bounce(self):
        return self.__bounce
    @bounce.setter
    def bounce(self, value = 0):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__bounce = [value]
    def setBounce(self, bounce = 0):
        if bounce == None or bounce  <  0:
            return None
        if bounce == None or bounce  >  1:
            return None
        self.__bounce = [bounce]
        return self
    def addBounce(self, bounce = 0):
        if bounce == None or bounce  <  0:
            return None
        if bounce == None or bounce  >  1:
            return None
        if self.__bounce == None:            self.__bounce =  []
        self.__bounce +=  [bounce]
        return self
    def removeBounce(self, bounce):
        self.__bounce = [x for x in self.__bounce if x not in bounce]
        return self.__bounce
    def getBounce(self, bounce = 0):
        return self.__bounce
    def bounce_changed(self, bounce = 0):
        return self.__bounce
    @property
    def contactNormal(self):
        return self.__contactNormal
    @contactNormal.setter
    def contactNormal(self, value = [0, 1, 0]):
        self.__contactNormal = [value]
    def setContactNormal(self, contactNormal = [0, 1, 0]):
        self.__contactNormal = [contactNormal]
        return self
    def addContactNormal(self, contactNormal = [0, 1, 0]):
        if self.__contactNormal == None:            self.__contactNormal =  []
        self.__contactNormal +=  [contactNormal]
        return self
    def removeContactNormal(self, contactNormal):
        self.__contactNormal = [x for x in self.__contactNormal if x not in contactNormal]
        return self.__contactNormal
    def getContactNormal(self, contactNormal = [0, 1, 0]):
        return self.__contactNormal
    def contactNormal_changed(self, contactNormal = [0, 1, 0]):
        return self.__contactNormal
    @property
    def depth(self):
        return self.__depth
    @depth.setter
    def depth(self, value = 0):
        self.__depth = [value]
    def setDepth(self, depth = 0):
        self.__depth = [depth]
        return self
    def addDepth(self, depth = 0):
        if self.__depth == None:            self.__depth =  []
        self.__depth +=  [depth]
        return self
    def removeDepth(self, depth):
        self.__depth = [x for x in self.__depth if x not in depth]
        return self.__depth
    def getDepth(self, depth = 0):
        return self.__depth
    def depth_changed(self, depth = 0):
        return self.__depth
    @property
    def frictionCoefficients(self):
        return self.__frictionCoefficients
    @frictionCoefficients.setter
    def frictionCoefficients(self, value = [0, 0]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        self.__frictionCoefficients = [value]
    def setFrictionCoefficients(self, frictionCoefficients = [0, 0]):
        if frictionCoefficients == None or len(frictionCoefficients) <= 0 or min(frictionCoefficients)  <  0:
            return None
        self.__frictionCoefficients = [frictionCoefficients]
        return self
    def addFrictionCoefficients(self, frictionCoefficients = [0, 0]):
        if frictionCoefficients == None or len(frictionCoefficients) <= 0 or min(frictionCoefficients)  <  0:
            return None
        if self.__frictionCoefficients == None:            self.__frictionCoefficients =  []
        self.__frictionCoefficients +=  [frictionCoefficients]
        return self
    def removeFrictionCoefficients(self, frictionCoefficients):
        self.__frictionCoefficients = [x for x in self.__frictionCoefficients if x not in frictionCoefficients]
        return self.__frictionCoefficients
    def getFrictionCoefficients(self, frictionCoefficients = [0, 0]):
        return self.__frictionCoefficients
    def frictionCoefficients_changed(self, frictionCoefficients = [0, 0]):
        return self.__frictionCoefficients
    @property
    def frictionDirection(self):
        return self.__frictionDirection
    @frictionDirection.setter
    def frictionDirection(self, value = [0, 1, 0]):
        self.__frictionDirection = [value]
    def setFrictionDirection(self, frictionDirection = [0, 1, 0]):
        self.__frictionDirection = [frictionDirection]
        return self
    def addFrictionDirection(self, frictionDirection = [0, 1, 0]):
        if self.__frictionDirection == None:            self.__frictionDirection =  []
        self.__frictionDirection +=  [frictionDirection]
        return self
    def removeFrictionDirection(self, frictionDirection):
        self.__frictionDirection = [x for x in self.__frictionDirection if x not in frictionDirection]
        return self.__frictionDirection
    def getFrictionDirection(self, frictionDirection = [0, 1, 0]):
        return self.__frictionDirection
    def frictionDirection_changed(self, frictionDirection = [0, 1, 0]):
        return self.__frictionDirection
    @property
    def geometry1(self):
        return self.__geometry1
    @geometry1.setter
    def geometry1(self, value = None):
        self.__geometry1 = [value]
    def setGeometry1(self, geometry1 = None):
        self.__geometry1 = [geometry1]
        return self
    def addGeometry1(self, geometry1 = None):
        if self.__geometry1 == None:            self.__geometry1 =  []
        self.__geometry1 +=  [geometry1]
        return self
    def removeGeometry1(self, geometry1):
        self.__geometry1 = [x for x in self.__geometry1 if x not in geometry1]
        return self.__geometry1
    def getGeometry1(self, geometry1 = None):
        return self.__geometry1
    def geometry1_changed(self, geometry1 = None):
        return self.__geometry1
    @property
    def geometry2(self):
        return self.__geometry2
    @geometry2.setter
    def geometry2(self, value = None):
        self.__geometry2 = [value]
    def setGeometry2(self, geometry2 = None):
        self.__geometry2 = [geometry2]
        return self
    def addGeometry2(self, geometry2 = None):
        if self.__geometry2 == None:            self.__geometry2 =  []
        self.__geometry2 +=  [geometry2]
        return self
    def removeGeometry2(self, geometry2):
        self.__geometry2 = [x for x in self.__geometry2 if x not in geometry2]
        return self.__geometry2
    def getGeometry2(self, geometry2 = None):
        return self.__geometry2
    def geometry2_changed(self, geometry2 = None):
        return self.__geometry2
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def minBounceSpeed(self):
        return self.__minBounceSpeed
    @minBounceSpeed.setter
    def minBounceSpeed(self, value = 0):
        if value == None or value  <  0:
            return None
        self.__minBounceSpeed = [value]
    def setMinBounceSpeed(self, minBounceSpeed = 0):
        if minBounceSpeed == None or minBounceSpeed  <  0:
            return None
        self.__minBounceSpeed = [minBounceSpeed]
        return self
    def addMinBounceSpeed(self, minBounceSpeed = 0):
        if minBounceSpeed == None or minBounceSpeed  <  0:
            return None
        if self.__minBounceSpeed == None:            self.__minBounceSpeed =  []
        self.__minBounceSpeed +=  [minBounceSpeed]
        return self
    def removeMinBounceSpeed(self, minBounceSpeed):
        self.__minBounceSpeed = [x for x in self.__minBounceSpeed if x not in minBounceSpeed]
        return self.__minBounceSpeed
    def getMinBounceSpeed(self, minBounceSpeed = 0):
        return self.__minBounceSpeed
    def minBounceSpeed_changed(self, minBounceSpeed = 0):
        return self.__minBounceSpeed
    @property
    def position(self):
        return self.__position
    @position.setter
    def position(self, value = [0, 0, 0]):
        self.__position = [value]
    def setPosition(self, position = [0, 0, 0]):
        self.__position = [position]
        return self
    def addPosition(self, position = [0, 0, 0]):
        if self.__position == None:            self.__position =  []
        self.__position +=  [position]
        return self
    def removePosition(self, position):
        self.__position = [x for x in self.__position if x not in position]
        return self.__position
    def getPosition(self, position = [0, 0, 0]):
        return self.__position
    def position_changed(self, position = [0, 0, 0]):
        return self.__position
    @property
    def slipCoefficients(self):
        return self.__slipCoefficients
    @slipCoefficients.setter
    def slipCoefficients(self, value = [0, 0]):
        self.__slipCoefficients = [value]
    def setSlipCoefficients(self, slipCoefficients = [0, 0]):
        self.__slipCoefficients = [slipCoefficients]
        return self
    def addSlipCoefficients(self, slipCoefficients = [0, 0]):
        if self.__slipCoefficients == None:            self.__slipCoefficients =  []
        self.__slipCoefficients +=  [slipCoefficients]
        return self
    def removeSlipCoefficients(self, slipCoefficients):
        self.__slipCoefficients = [x for x in self.__slipCoefficients if x not in slipCoefficients]
        return self.__slipCoefficients
    def getSlipCoefficients(self, slipCoefficients = [0, 0]):
        return self.__slipCoefficients
    def slipCoefficients_changed(self, slipCoefficients = [0, 0]):
        return self.__slipCoefficients
    @property
    def softnessConstantForceMix(self):
        return self.__softnessConstantForceMix
    @softnessConstantForceMix.setter
    def softnessConstantForceMix(self, value = 0.0001):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__softnessConstantForceMix = [value]
    def setSoftnessConstantForceMix(self, softnessConstantForceMix = 0.0001):
        if softnessConstantForceMix == None or softnessConstantForceMix  <  0:
            return None
        if softnessConstantForceMix == None or softnessConstantForceMix  >  1:
            return None
        self.__softnessConstantForceMix = [softnessConstantForceMix]
        return self
    def addSoftnessConstantForceMix(self, softnessConstantForceMix = 0.0001):
        if softnessConstantForceMix == None or softnessConstantForceMix  <  0:
            return None
        if softnessConstantForceMix == None or softnessConstantForceMix  >  1:
            return None
        if self.__softnessConstantForceMix == None:            self.__softnessConstantForceMix =  []
        self.__softnessConstantForceMix +=  [softnessConstantForceMix]
        return self
    def removeSoftnessConstantForceMix(self, softnessConstantForceMix):
        self.__softnessConstantForceMix = [x for x in self.__softnessConstantForceMix if x not in softnessConstantForceMix]
        return self.__softnessConstantForceMix
    def getSoftnessConstantForceMix(self, softnessConstantForceMix = 0.0001):
        return self.__softnessConstantForceMix
    def softnessConstantForceMix_changed(self, softnessConstantForceMix = 0.0001):
        return self.__softnessConstantForceMix
    @property
    def softnessErrorCorrection(self):
        return self.__softnessErrorCorrection
    @softnessErrorCorrection.setter
    def softnessErrorCorrection(self, value = 0.8):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__softnessErrorCorrection = [value]
    def setSoftnessErrorCorrection(self, softnessErrorCorrection = 0.8):
        if softnessErrorCorrection == None or softnessErrorCorrection  <  0:
            return None
        if softnessErrorCorrection == None or softnessErrorCorrection  >  1:
            return None
        self.__softnessErrorCorrection = [softnessErrorCorrection]
        return self
    def addSoftnessErrorCorrection(self, softnessErrorCorrection = 0.8):
        if softnessErrorCorrection == None or softnessErrorCorrection  <  0:
            return None
        if softnessErrorCorrection == None or softnessErrorCorrection  >  1:
            return None
        if self.__softnessErrorCorrection == None:            self.__softnessErrorCorrection =  []
        self.__softnessErrorCorrection +=  [softnessErrorCorrection]
        return self
    def removeSoftnessErrorCorrection(self, softnessErrorCorrection):
        self.__softnessErrorCorrection = [x for x in self.__softnessErrorCorrection if x not in softnessErrorCorrection]
        return self.__softnessErrorCorrection
    def getSoftnessErrorCorrection(self, softnessErrorCorrection = 0.8):
        return self.__softnessErrorCorrection
    def softnessErrorCorrection_changed(self, softnessErrorCorrection = 0.8):
        return self.__softnessErrorCorrection
    @property
    def surfaceSpeed(self):
        return self.__surfaceSpeed
    @surfaceSpeed.setter
    def surfaceSpeed(self, value = [0, 0]):
        self.__surfaceSpeed = [value]
    def setSurfaceSpeed(self, surfaceSpeed = [0, 0]):
        self.__surfaceSpeed = [surfaceSpeed]
        return self
    def addSurfaceSpeed(self, surfaceSpeed = [0, 0]):
        if self.__surfaceSpeed == None:            self.__surfaceSpeed =  []
        self.__surfaceSpeed +=  [surfaceSpeed]
        return self
    def removeSurfaceSpeed(self, surfaceSpeed):
        self.__surfaceSpeed = [x for x in self.__surfaceSpeed if x not in surfaceSpeed]
        return self.__surfaceSpeed
    def getSurfaceSpeed(self, surfaceSpeed = [0, 0]):
        return self.__surfaceSpeed
    def surfaceSpeed_changed(self, surfaceSpeed = [0, 0]):
        return self.__surfaceSpeed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Contact'
        if self.__appliedParameters is not None:
            if isinstance(self.__appliedParameters, six.string_types):
                str += ' appliedParameters="'+self.__appliedParameters+'"'
            else:
                str += ' appliedParameters="'+self.__appliedParameters[0]+'"'
        if self.__bounce is not None:
            if isinstance(self.__bounce, six.string_types):
                str += ' bounce="'+self.__bounce+'"'
            else:
                str += ' bounce="'+self.__bounce[0]+'"'
        if self.__contactNormal is not None:
            if isinstance(self.__contactNormal, six.string_types):
                str += ' contactNormal="'+self.__contactNormal+'"'
            else:
                str += ' contactNormal="'+self.__contactNormal[0]+'"'
        if self.__depth is not None:
            if isinstance(self.__depth, six.string_types):
                str += ' depth="'+self.__depth+'"'
            else:
                str += ' depth="'+self.__depth[0]+'"'
        if self.__frictionCoefficients is not None:
            if isinstance(self.__frictionCoefficients, six.string_types):
                str += ' frictionCoefficients="'+self.__frictionCoefficients+'"'
            else:
                str += ' frictionCoefficients="'+self.__frictionCoefficients[0]+'"'
        if self.__frictionDirection is not None:
            if isinstance(self.__frictionDirection, six.string_types):
                str += ' frictionDirection="'+self.__frictionDirection+'"'
            else:
                str += ' frictionDirection="'+self.__frictionDirection[0]+'"'
        if self.__minBounceSpeed is not None:
            if isinstance(self.__minBounceSpeed, six.string_types):
                str += ' minBounceSpeed="'+self.__minBounceSpeed+'"'
            else:
                str += ' minBounceSpeed="'+self.__minBounceSpeed[0]+'"'
        if self.__position is not None:
            if isinstance(self.__position, six.string_types):
                str += ' position="'+self.__position+'"'
            else:
                str += ' position="'+self.__position[0]+'"'
        if self.__slipCoefficients is not None:
            if isinstance(self.__slipCoefficients, six.string_types):
                str += ' slipCoefficients="'+self.__slipCoefficients+'"'
            else:
                str += ' slipCoefficients="'+self.__slipCoefficients[0]+'"'
        if self.__softnessConstantForceMix is not None:
            if isinstance(self.__softnessConstantForceMix, six.string_types):
                str += ' softnessConstantForceMix="'+self.__softnessConstantForceMix+'"'
            else:
                str += ' softnessConstantForceMix="'+self.__softnessConstantForceMix[0]+'"'
        if self.__softnessErrorCorrection is not None:
            if isinstance(self.__softnessErrorCorrection, six.string_types):
                str += ' softnessErrorCorrection="'+self.__softnessErrorCorrection+'"'
            else:
                str += ' softnessErrorCorrection="'+self.__softnessErrorCorrection[0]+'"'
        if self.__surfaceSpeed is not None:
            if isinstance(self.__surfaceSpeed, six.string_types):
                str += ' surfaceSpeed="'+self.__surfaceSpeed+'"'
            else:
                str += ' surfaceSpeed="'+self.__surfaceSpeed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<body1'
        if self.__body1 is not None:
           for s in self.__body1:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__body1 is not None:
           for s in self.__body1:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</body1>'
        str += '<body2'
        if self.__body2 is not None:
           for s in self.__body2:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__body2 is not None:
           for s in self.__body2:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</body2>'
        str += '<geometry1'
        if self.__geometry1 is not None:
           for s in self.__geometry1:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__geometry1 is not None:
           for s in self.__geometry1:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</geometry1>'
        str += '<geometry2'
        if self.__geometry2 is not None:
           for s in self.__geometry2:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__geometry2 is not None:
           for s in self.__geometry2:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</geometry2>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</Contact>'
        return str


class Contour2D(X3DNode):
    def __init__(self, **kwargs):
        super(Contour2D, self).__init__(**kwargs)
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        children  = kwargs.pop("children", None)
        self.__children = children
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    def addChildren(self, Children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [Children]
        return self
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Contour2D'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '</Contour2D>'
        return str


class ContourPolyline2D(X3DNurbsControlCurveNode):
    def __init__(self, **kwargs):
        super(ContourPolyline2D, self).__init__(**kwargs)
        controlPoint  = kwargs.pop("controlPoint", None)
        self.__controlPoint = controlPoint
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def controlPoint(self):
        return self.__controlPoint
    @controlPoint.setter
    def controlPoint(self, value = None):
        self.__controlPoint = [value]
    def setControlPoint(self, controlPoint = None):
        self.__controlPoint = [controlPoint]
        return self
    def addControlPoint(self, controlPoint = None):
        if self.__controlPoint == None:            self.__controlPoint =  []
        self.__controlPoint +=  [controlPoint]
        return self
    def removeControlPoint(self, controlPoint):
        self.__controlPoint = [x for x in self.__controlPoint if x not in controlPoint]
        return self.__controlPoint
    def getControlPoint(self, controlPoint = None):
        return self.__controlPoint
    def controlPoint_changed(self, controlPoint = None):
        return self.__controlPoint
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ContourPolyline2D'
        if self.__controlPoint is not None:
            if isinstance(self.__controlPoint, six.string_types):
                str += ' controlPoint="'+self.__controlPoint+'"'
            else:
                str += ' controlPoint="'+self.__controlPoint[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</ContourPolyline2D>'
        return str


class Coordinate(X3DCoordinateNode):
    def __init__(self, **kwargs):
        super(Coordinate, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        point  = kwargs.pop("point", None)
        self.__point = point
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def point(self):
        return self.__point
    @point.setter
    def point(self, value = None):
        self.__point = [value]
    def setPoint(self, point = None):
        self.__point = [point]
        return self
    def addPoint(self, point = None):
        if self.__point == None:            self.__point =  []
        self.__point +=  [point]
        return self
    def removePoint(self, point):
        self.__point = [x for x in self.__point if x not in point]
        return self.__point
    def getPoint(self, point = None):
        return self.__point
    def point_changed(self, point = None):
        return self.__point
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Coordinate'
        if self.__point is not None:
            if isinstance(self.__point, six.string_types):
                str += ' point="'+self.__point+'"'
            else:
                str += ' point="'+self.__point[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</Coordinate>'
        return str


class CoordinateChaser(X3DChaserNode):
    def __init__(self, **kwargs):
        super(CoordinateChaser, self).__init__(**kwargs)
        duration  = kwargs.pop("duration", 1)
        if duration == None or duration  <  0:
            return None
        self.__duration = duration
        initialDestination  = kwargs.pop("initialDestination", [0, 0, 0])
        self.__initialDestination = initialDestination
        initialValue  = kwargs.pop("initialValue", [0, 0, 0])
        self.__initialValue = initialValue
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        destination  = kwargs.pop("destination", None)
        self.__destination = destination
        value  = kwargs.pop("value", None)
        self.__value = value
        value_changed  = kwargs.pop("value_changed", None)
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def isActive(self, Active = None):
        return self.__Active
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def destination(self):
        return self.__destination
    @destination.setter
    def destination(self, value = None):
        self.__destination = [value]
    def set_destination(self, destination = None):
        self.__destination = [destination]
        return self
    @property
    def value(self):
        return self.__value
    @value.setter
    def value(self, value = None):
        self.__value = [value]
    def set_value(self, value = None):
        self.__value = [value]
        return self
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<CoordinateChaser'
        if self.__duration is not None:
            if isinstance(self.__duration, six.string_types):
                str += ' duration="'+self.__duration+'"'
            else:
                str += ' duration="'+self.__duration[0]+'"'
        if self.__initialDestination is not None:
            if isinstance(self.__initialDestination, six.string_types):
                str += ' initialDestination="'+self.__initialDestination+'"'
            else:
                str += ' initialDestination="'+self.__initialDestination[0]+'"'
        if self.__initialValue is not None:
            if isinstance(self.__initialValue, six.string_types):
                str += ' initialValue="'+self.__initialValue+'"'
            else:
                str += ' initialValue="'+self.__initialValue[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__destination is not None:
            if isinstance(self.__destination, six.string_types):
                str += ' destination="'+self.__destination+'"'
            else:
                str += ' destination="'+self.__destination[0]+'"'
        if self.__value is not None:
            if isinstance(self.__value, six.string_types):
                str += ' value="'+self.__value+'"'
            else:
                str += ' value="'+self.__value[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</CoordinateChaser>'
        return str


class CoordinateDamper(X3DDamperNode):
    def __init__(self, **kwargs):
        super(CoordinateDamper, self).__init__(**kwargs)
        initialDestination  = kwargs.pop("initialDestination", [0, 0, 0])
        self.__initialDestination = initialDestination
        initialValue  = kwargs.pop("initialValue", [0, 0, 0])
        self.__initialValue = initialValue
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        order  = kwargs.pop("order", 3)
        if order == None or order  <  0:
            return None
        if order == None or order  >  5:
            return None
        self.__order = order
        destination  = kwargs.pop("destination", None)
        self.__destination = destination
        value  = kwargs.pop("value", None)
        self.__value = value
        tau  = kwargs.pop("tau", 0.3)
        if tau == None or tau  <  0:
            return None
        self.__tau = tau
        tolerance  = kwargs.pop("tolerance", -1)
        self.__tolerance = tolerance
        value_changed  = kwargs.pop("value_changed", None)
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def isActive(self, Active = None):
        return self.__Active
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def destination(self):
        return self.__destination
    @destination.setter
    def destination(self, value = None):
        self.__destination = [value]
    def set_destination(self, destination = None):
        self.__destination = [destination]
        return self
    @property
    def value(self):
        return self.__value
    @value.setter
    def value(self, value = None):
        self.__value = [value]
    def set_value(self, value = None):
        self.__value = [value]
        return self
    @property
    def tau(self):
        return self.__tau
    @tau.setter
    def tau(self, value = 0.3):
        if value == None or value  <  0:
            return None
        self.__tau = [value]
    def setTau(self, tau = 0.3):
        if tau == None or tau  <  0:
            return None
        self.__tau = [tau]
        return self
    def addTau(self, tau = 0.3):
        if tau == None or tau  <  0:
            return None
        if self.__tau == None:            self.__tau =  []
        self.__tau +=  [tau]
        return self
    def removeTau(self, tau):
        self.__tau = [x for x in self.__tau if x not in tau]
        return self.__tau
    def getTau(self, tau = 0.3):
        return self.__tau
    def tau_changed(self, tau = 0.3):
        return self.__tau
    @property
    def tolerance(self):
        return self.__tolerance
    @tolerance.setter
    def tolerance(self, value = -1):
        self.__tolerance = [value]
    def setTolerance(self, tolerance = -1):
        self.__tolerance = [tolerance]
        return self
    def addTolerance(self, tolerance = -1):
        if self.__tolerance == None:            self.__tolerance =  []
        self.__tolerance +=  [tolerance]
        return self
    def removeTolerance(self, tolerance):
        self.__tolerance = [x for x in self.__tolerance if x not in tolerance]
        return self.__tolerance
    def getTolerance(self, tolerance = -1):
        return self.__tolerance
    def tolerance_changed(self, tolerance = -1):
        return self.__tolerance
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<CoordinateDamper'
        if self.__initialDestination is not None:
            if isinstance(self.__initialDestination, six.string_types):
                str += ' initialDestination="'+self.__initialDestination+'"'
            else:
                str += ' initialDestination="'+self.__initialDestination[0]+'"'
        if self.__initialValue is not None:
            if isinstance(self.__initialValue, six.string_types):
                str += ' initialValue="'+self.__initialValue+'"'
            else:
                str += ' initialValue="'+self.__initialValue[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__order is not None:
            if isinstance(self.__order, six.string_types):
                str += ' order="'+self.__order+'"'
            else:
                str += ' order="'+self.__order[0]+'"'
        if self.__destination is not None:
            if isinstance(self.__destination, six.string_types):
                str += ' destination="'+self.__destination+'"'
            else:
                str += ' destination="'+self.__destination[0]+'"'
        if self.__value is not None:
            if isinstance(self.__value, six.string_types):
                str += ' value="'+self.__value+'"'
            else:
                str += ' value="'+self.__value[0]+'"'
        if self.__tau is not None:
            if isinstance(self.__tau, six.string_types):
                str += ' tau="'+self.__tau+'"'
            else:
                str += ' tau="'+self.__tau[0]+'"'
        if self.__tolerance is not None:
            if isinstance(self.__tolerance, six.string_types):
                str += ' tolerance="'+self.__tolerance+'"'
            else:
                str += ' tolerance="'+self.__tolerance[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</CoordinateDamper>'
        return str


class CoordinateDouble(X3DCoordinateNode):
    def __init__(self, **kwargs):
        super(CoordinateDouble, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        point  = kwargs.pop("point", None)
        self.__point = point
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def point(self):
        return self.__point
    @point.setter
    def point(self, value = None):
        self.__point = [value]
    def setPoint(self, point = None):
        self.__point = [point]
        return self
    def addPoint(self, point = None):
        if self.__point == None:            self.__point =  []
        self.__point +=  [point]
        return self
    def removePoint(self, point):
        self.__point = [x for x in self.__point if x not in point]
        return self.__point
    def getPoint(self, point = None):
        return self.__point
    def point_changed(self, point = None):
        return self.__point
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<CoordinateDouble'
        if self.__point is not None:
            if isinstance(self.__point, six.string_types):
                str += ' point="'+self.__point+'"'
            else:
                str += ' point="'+self.__point[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</CoordinateDouble>'
        return str


class CoordinateInterpolator(X3DInterpolatorNode):
    def __init__(self, **kwargs):
        super(CoordinateInterpolator, self).__init__(**kwargs)
        key  = kwargs.pop("key", None)
        self.__key = key
        keyValue  = kwargs.pop("keyValue", None)
        self.__keyValue = keyValue
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        fraction  = kwargs.pop("fraction", None)
        self.__fraction = fraction
        value_changed  = kwargs.pop("value_changed", None)
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def key(self):
        return self.__key
    @key.setter
    def key(self, value = None):
        self.__key = [value]
    def setKey(self, key = None):
        self.__key = [key]
        return self
    def addKey(self, key = None):
        if self.__key == None:            self.__key =  []
        self.__key +=  [key]
        return self
    def removeKey(self, key):
        self.__key = [x for x in self.__key if x not in key]
        return self.__key
    def getKey(self, key = None):
        return self.__key
    def key_changed(self, key = None):
        return self.__key
    @property
    def keyValue(self):
        return self.__keyValue
    @keyValue.setter
    def keyValue(self, value = None):
        self.__keyValue = [value]
    def setKeyValue(self, keyValue = None):
        self.__keyValue = [keyValue]
        return self
    def addKeyValue(self, keyValue = None):
        if self.__keyValue == None:            self.__keyValue =  []
        self.__keyValue +=  [keyValue]
        return self
    def removeKeyValue(self, keyValue):
        self.__keyValue = [x for x in self.__keyValue if x not in keyValue]
        return self.__keyValue
    def getKeyValue(self, keyValue = None):
        return self.__keyValue
    def keyValue_changed(self, keyValue = None):
        return self.__keyValue
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def fraction(self):
        return self.__fraction
    @fraction.setter
    def fraction(self, value = None):
        self.__fraction = [value]
    def set_fraction(self, fraction = None):
        self.__fraction = [fraction]
        return self
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<CoordinateInterpolator'
        if self.__key is not None:
            if isinstance(self.__key, six.string_types):
                str += ' key="'+self.__key+'"'
            else:
                str += ' key="'+self.__key[0]+'"'
        if self.__keyValue is not None:
            if isinstance(self.__keyValue, six.string_types):
                str += ' keyValue="'+self.__keyValue+'"'
            else:
                str += ' keyValue="'+self.__keyValue[0]+'"'
        if self.__fraction is not None:
            if isinstance(self.__fraction, six.string_types):
                str += ' fraction="'+self.__fraction+'"'
            else:
                str += ' fraction="'+self.__fraction[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</CoordinateInterpolator>'
        return str


class CoordinateInterpolator2D(X3DInterpolatorNode):
    def __init__(self, **kwargs):
        super(CoordinateInterpolator2D, self).__init__(**kwargs)
        key  = kwargs.pop("key", None)
        self.__key = key
        keyValue  = kwargs.pop("keyValue", None)
        self.__keyValue = keyValue
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        fraction  = kwargs.pop("fraction", None)
        self.__fraction = fraction
        value_changed  = kwargs.pop("value_changed", None)
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def key(self):
        return self.__key
    @key.setter
    def key(self, value = None):
        self.__key = [value]
    def setKey(self, key = None):
        self.__key = [key]
        return self
    def addKey(self, key = None):
        if self.__key == None:            self.__key =  []
        self.__key +=  [key]
        return self
    def removeKey(self, key):
        self.__key = [x for x in self.__key if x not in key]
        return self.__key
    def getKey(self, key = None):
        return self.__key
    def key_changed(self, key = None):
        return self.__key
    @property
    def keyValue(self):
        return self.__keyValue
    @keyValue.setter
    def keyValue(self, value = None):
        self.__keyValue = [value]
    def setKeyValue(self, keyValue = None):
        self.__keyValue = [keyValue]
        return self
    def addKeyValue(self, keyValue = None):
        if self.__keyValue == None:            self.__keyValue =  []
        self.__keyValue +=  [keyValue]
        return self
    def removeKeyValue(self, keyValue):
        self.__keyValue = [x for x in self.__keyValue if x not in keyValue]
        return self.__keyValue
    def getKeyValue(self, keyValue = None):
        return self.__keyValue
    def keyValue_changed(self, keyValue = None):
        return self.__keyValue
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def fraction(self):
        return self.__fraction
    @fraction.setter
    def fraction(self, value = None):
        self.__fraction = [value]
    def set_fraction(self, fraction = None):
        self.__fraction = [fraction]
        return self
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<CoordinateInterpolator2D'
        if self.__key is not None:
            if isinstance(self.__key, six.string_types):
                str += ' key="'+self.__key+'"'
            else:
                str += ' key="'+self.__key[0]+'"'
        if self.__keyValue is not None:
            if isinstance(self.__keyValue, six.string_types):
                str += ' keyValue="'+self.__keyValue+'"'
            else:
                str += ' keyValue="'+self.__keyValue[0]+'"'
        if self.__fraction is not None:
            if isinstance(self.__fraction, six.string_types):
                str += ' fraction="'+self.__fraction+'"'
            else:
                str += ' fraction="'+self.__fraction[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</CoordinateInterpolator2D>'
        return str


class Cylinder(X3DGeometryNode):
    def __init__(self, **kwargs):
        super(Cylinder, self).__init__(**kwargs)
        bottom  = kwargs.pop("bottom", True)
        self.__bottom = bottom
        height  = kwargs.pop("height", 2)
        if height == None or height  <=  0:
            return None
        self.__height = height
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        radius  = kwargs.pop("radius", 1)
        if radius == None or radius  <=  0:
            return None
        self.__radius = radius
        side  = kwargs.pop("side", True)
        self.__side = side
        solid  = kwargs.pop("solid", True)
        self.__solid = solid
        top  = kwargs.pop("top", True)
        self.__top = top
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def top(self):
        return self.__top
    @top.setter
    def top(self, value = True):
        self.__top = [value]
    def setTop(self, top = True):
        self.__top = [top]
        return self
    def addTop(self, top = True):
        if self.__top == None:            self.__top =  []
        self.__top +=  [top]
        return self
    def removeTop(self, top):
        self.__top = [x for x in self.__top if x not in top]
        return self.__top
    def isTop(self, top = True):
        return self.__top
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Cylinder'
        if self.__bottom is not None:
            if isinstance(self.__bottom, six.string_types):
                str += ' bottom="'+self.__bottom+'"'
            else:
                str += ' bottom="'+self.__bottom[0]+'"'
        if self.__height is not None:
            if isinstance(self.__height, six.string_types):
                str += ' height="'+self.__height+'"'
            else:
                str += ' height="'+self.__height[0]+'"'
        if self.__radius is not None:
            if isinstance(self.__radius, six.string_types):
                str += ' radius="'+self.__radius+'"'
            else:
                str += ' radius="'+self.__radius[0]+'"'
        if self.__side is not None:
            if isinstance(self.__side, six.string_types):
                str += ' side="'+self.__side+'"'
            else:
                str += ' side="'+self.__side[0]+'"'
        if self.__solid is not None:
            if isinstance(self.__solid, six.string_types):
                str += ' solid="'+self.__solid+'"'
            else:
                str += ' solid="'+self.__solid[0]+'"'
        if self.__top is not None:
            if isinstance(self.__top, six.string_types):
                str += ' top="'+self.__top+'"'
            else:
                str += ' top="'+self.__top[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</Cylinder>'
        return str


class CylinderSensor(X3DDragSensorNode):
    def __init__(self, **kwargs):
        super(CylinderSensor, self).__init__(**kwargs)
        autoOffset  = kwargs.pop("autoOffset", True)
        self.__autoOffset = autoOffset
        axisRotation  = kwargs.pop("axisRotation", [0, 1, 0, 0])
        self.__axisRotation = axisRotation
        description  = kwargs.pop("description", None)
        self.__description = description
        diskAngle  = kwargs.pop("diskAngle", 0.26179167)
        if diskAngle == None or diskAngle  <  0:
            return None
        if diskAngle == None or diskAngle  >  1.5708:
            return None
        self.__diskAngle = diskAngle
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        Over  = kwargs.pop("Over", None)
        self.__Over = Over
        maxAngle  = kwargs.pop("maxAngle", -1)
        if maxAngle == None or maxAngle  <=  -6.2832:
            return None
        if maxAngle == None or maxAngle  >=  6.2832:
            return None
        self.__maxAngle = maxAngle
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        minAngle  = kwargs.pop("minAngle", 0)
        if minAngle == None or minAngle  <=  -6.2832:
            return None
        if minAngle == None or minAngle  >=  6.2832:
            return None
        self.__minAngle = minAngle
        offset  = kwargs.pop("offset", 0)
        self.__offset = offset
        rotation_changed  = kwargs.pop("rotation_changed", None)
        self.__rotation_changed = rotation_changed
        trackPoint_changed  = kwargs.pop("trackPoint_changed", None)
        self.__trackPoint_changed = trackPoint_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def autoOffset(self):
        return self.__autoOffset
    @autoOffset.setter
    def autoOffset(self, value = True):
        self.__autoOffset = [value]
    def setAutoOffset(self, autoOffset = True):
        self.__autoOffset = [autoOffset]
        return self
    def addAutoOffset(self, autoOffset = True):
        if self.__autoOffset == None:            self.__autoOffset =  []
        self.__autoOffset +=  [autoOffset]
        return self
    def removeAutoOffset(self, autoOffset):
        self.__autoOffset = [x for x in self.__autoOffset if x not in autoOffset]
        return self.__autoOffset
    def isAutoOffset(self, autoOffset = True):
        return self.__autoOffset
    @property
    def axisRotation(self):
        return self.__axisRotation
    @axisRotation.setter
    def axisRotation(self, value = [0, 1, 0, 0]):
        self.__axisRotation = [value]
    def setAxisRotation(self, axisRotation = [0, 1, 0, 0]):
        self.__axisRotation = [axisRotation]
        return self
    def addAxisRotation(self, axisRotation = [0, 1, 0, 0]):
        if self.__axisRotation == None:            self.__axisRotation =  []
        self.__axisRotation +=  [axisRotation]
        return self
    def removeAxisRotation(self, axisRotation):
        self.__axisRotation = [x for x in self.__axisRotation if x not in axisRotation]
        return self.__axisRotation
    def getAxisRotation(self, axisRotation = [0, 1, 0, 0]):
        return self.__axisRotation
    def axisRotation_changed(self, axisRotation = [0, 1, 0, 0]):
        return self.__axisRotation
    @property
    def description(self):
        return self.__description
    @description.setter
    def description(self, value = None):
        self.__description = [value]
    def setDescription(self, description = None):
        self.__description = [description]
        return self
    def addDescription(self, description = None):
        if self.__description == None:            self.__description =  []
        self.__description +=  [description]
        return self
    def removeDescription(self, description):
        self.__description = [x for x in self.__description if x not in description]
        return self.__description
    def getDescription(self, description = None):
        return self.__description
    def description_changed(self, description = None):
        return self.__description
    @property
    def diskAngle(self):
        return self.__diskAngle
    @diskAngle.setter
    def diskAngle(self, value = 0.26179167):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1.5708:
            return None
        self.__diskAngle = [value]
    def setDiskAngle(self, diskAngle = 0.26179167):
        if diskAngle == None or diskAngle  <  0:
            return None
        if diskAngle == None or diskAngle  >  1.5708:
            return None
        self.__diskAngle = [diskAngle]
        return self
    def addDiskAngle(self, diskAngle = 0.26179167):
        if diskAngle == None or diskAngle  <  0:
            return None
        if diskAngle == None or diskAngle  >  1.5708:
            return None
        if self.__diskAngle == None:            self.__diskAngle =  []
        self.__diskAngle +=  [diskAngle]
        return self
    def removeDiskAngle(self, diskAngle):
        self.__diskAngle = [x for x in self.__diskAngle if x not in diskAngle]
        return self.__diskAngle
    def getDiskAngle(self, diskAngle = 0.26179167):
        return self.__diskAngle
    def diskAngle_changed(self, diskAngle = 0.26179167):
        return self.__diskAngle
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    def isActive(self, Active = None):
        return self.__Active
    def isOver(self, Over = None):
        return self.__Over
    @property
    def maxAngle(self):
        return self.__maxAngle
    @maxAngle.setter
    def maxAngle(self, value = -1):
        if value == None or value  <=  -6.2832:
            return None
        if value == None or value  >=  6.2832:
            return None
        self.__maxAngle = [value]
    def setMaxAngle(self, maxAngle = -1):
        if maxAngle == None or maxAngle  <=  -6.2832:
            return None
        if maxAngle == None or maxAngle  >=  6.2832:
            return None
        self.__maxAngle = [maxAngle]
        return self
    def addMaxAngle(self, maxAngle = -1):
        if maxAngle == None or maxAngle  <=  -6.2832:
            return None
        if maxAngle == None or maxAngle  >=  6.2832:
            return None
        if self.__maxAngle == None:            self.__maxAngle =  []
        self.__maxAngle +=  [maxAngle]
        return self
    def removeMaxAngle(self, maxAngle):
        self.__maxAngle = [x for x in self.__maxAngle if x not in maxAngle]
        return self.__maxAngle
    def getMaxAngle(self, maxAngle = -1):
        return self.__maxAngle
    def maxAngle_changed(self, maxAngle = -1):
        return self.__maxAngle
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def minAngle(self):
        return self.__minAngle
    @minAngle.setter
    def minAngle(self, value = 0):
        if value == None or value  <=  -6.2832:
            return None
        if value == None or value  >=  6.2832:
            return None
        self.__minAngle = [value]
    def setMinAngle(self, minAngle = 0):
        if minAngle == None or minAngle  <=  -6.2832:
            return None
        if minAngle == None or minAngle  >=  6.2832:
            return None
        self.__minAngle = [minAngle]
        return self
    def addMinAngle(self, minAngle = 0):
        if minAngle == None or minAngle  <=  -6.2832:
            return None
        if minAngle == None or minAngle  >=  6.2832:
            return None
        if self.__minAngle == None:            self.__minAngle =  []
        self.__minAngle +=  [minAngle]
        return self
    def removeMinAngle(self, minAngle):
        self.__minAngle = [x for x in self.__minAngle if x not in minAngle]
        return self.__minAngle
    def getMinAngle(self, minAngle = 0):
        return self.__minAngle
    def minAngle_changed(self, minAngle = 0):
        return self.__minAngle
    @property
    def offset(self):
        return self.__offset
    @offset.setter
    def offset(self, value = 0):
        self.__offset = [value]
    def setOffset(self, offset = 0):
        self.__offset = [offset]
        return self
    def addOffset(self, offset = 0):
        if self.__offset == None:            self.__offset =  []
        self.__offset +=  [offset]
        return self
    def removeOffset(self, offset):
        self.__offset = [x for x in self.__offset if x not in offset]
        return self.__offset
    def getOffset(self, offset = 0):
        return self.__offset
    def offset_changed(self, offset = 0):
        return self.__offset
    def removerotation_changed(self, rotation_changed):
        self.__rotation_changed = [x for x in self.__rotation_changed if x not in rotation_changed]
        return self.__rotation_changed
    def getrotation_changed(self, rotation_changed = None):
        return self.__rotation_changed
    def rotation_changed_changed(self, rotation_changed = None):
        return self.__rotation_changed
    def removetrackPoint_changed(self, trackPoint_changed):
        self.__trackPoint_changed = [x for x in self.__trackPoint_changed if x not in trackPoint_changed]
        return self.__trackPoint_changed
    def gettrackPoint_changed(self, trackPoint_changed = None):
        return self.__trackPoint_changed
    def trackPoint_changed_changed(self, trackPoint_changed = None):
        return self.__trackPoint_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<CylinderSensor'
        if self.__autoOffset is not None:
            if isinstance(self.__autoOffset, six.string_types):
                str += ' autoOffset="'+self.__autoOffset+'"'
            else:
                str += ' autoOffset="'+self.__autoOffset[0]+'"'
        if self.__axisRotation is not None:
            if isinstance(self.__axisRotation, six.string_types):
                str += ' axisRotation="'+self.__axisRotation+'"'
            else:
                str += ' axisRotation="'+self.__axisRotation[0]+'"'
        if self.__description is not None:
            if isinstance(self.__description, six.string_types):
                str += ' description="'+self.__description+'"'
            else:
                str += ' description="'+self.__description[0]+'"'
        if self.__diskAngle is not None:
            if isinstance(self.__diskAngle, six.string_types):
                str += ' diskAngle="'+self.__diskAngle+'"'
            else:
                str += ' diskAngle="'+self.__diskAngle[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__Over is not None:
            if isinstance(self.__Over, six.string_types):
                str += ' Over="'+self.__Over+'"'
            else:
                str += ' Over="'+self.__Over[0]+'"'
        if self.__maxAngle is not None:
            if isinstance(self.__maxAngle, six.string_types):
                str += ' maxAngle="'+self.__maxAngle+'"'
            else:
                str += ' maxAngle="'+self.__maxAngle[0]+'"'
        if self.__minAngle is not None:
            if isinstance(self.__minAngle, six.string_types):
                str += ' minAngle="'+self.__minAngle+'"'
            else:
                str += ' minAngle="'+self.__minAngle[0]+'"'
        if self.__offset is not None:
            if isinstance(self.__offset, six.string_types):
                str += ' offset="'+self.__offset+'"'
            else:
                str += ' offset="'+self.__offset[0]+'"'
        if self.__rotation_changed is not None:
            if isinstance(self.__rotation_changed, six.string_types):
                str += ' rotation_changed="'+self.__rotation_changed+'"'
            else:
                str += ' rotation_changed="'+self.__rotation_changed[0]+'"'
        if self.__trackPoint_changed is not None:
            if isinstance(self.__trackPoint_changed, six.string_types):
                str += ' trackPoint_changed="'+self.__trackPoint_changed+'"'
            else:
                str += ' trackPoint_changed="'+self.__trackPoint_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</CylinderSensor>'
        return str


class DirectionalLight(X3DLightNode):
    def __init__(self, **kwargs):
        super(DirectionalLight, self).__init__(**kwargs)
        ambientIntensity  = kwargs.pop("ambientIntensity", 0)
        if ambientIntensity == None or ambientIntensity  <  0:
            return None
        if ambientIntensity == None or ambientIntensity  >  1:
            return None
        self.__ambientIntensity = ambientIntensity
        color  = kwargs.pop("color", [1, 1, 1])
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        self.__color = color
        direction  = kwargs.pop("direction", [0, 0, -1])
        self.__direction = direction
        global_  = kwargs.pop("global_", False)
        self.__global_ = global_
        intensity  = kwargs.pop("intensity", 1)
        if intensity == None or intensity  <  0:
            return None
        if intensity == None or intensity  >  1:
            return None
        self.__intensity = intensity
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        on  = kwargs.pop("on", True)
        self.__on = on
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def ambientIntensity(self):
        return self.__ambientIntensity
    @ambientIntensity.setter
    def ambientIntensity(self, value = 0):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__ambientIntensity = [value]
    def setAmbientIntensity(self, ambientIntensity = 0):
        if ambientIntensity == None or ambientIntensity  <  0:
            return None
        if ambientIntensity == None or ambientIntensity  >  1:
            return None
        self.__ambientIntensity = [ambientIntensity]
        return self
    def addAmbientIntensity(self, ambientIntensity = 0):
        if ambientIntensity == None or ambientIntensity  <  0:
            return None
        if ambientIntensity == None or ambientIntensity  >  1:
            return None
        if self.__ambientIntensity == None:            self.__ambientIntensity =  []
        self.__ambientIntensity +=  [ambientIntensity]
        return self
    def removeAmbientIntensity(self, ambientIntensity):
        self.__ambientIntensity = [x for x in self.__ambientIntensity if x not in ambientIntensity]
        return self.__ambientIntensity
    def getAmbientIntensity(self, ambientIntensity = 0):
        return self.__ambientIntensity
    def ambientIntensity_changed(self, ambientIntensity = 0):
        return self.__ambientIntensity
    @property
    def color(self):
        return self.__color
    @color.setter
    def color(self, value = [1, 1, 1]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__color = [value]
    def setColor(self, color = [1, 1, 1]):
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        self.__color = [color]
        return self
    def addColor(self, color = [1, 1, 1]):
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        if self.__color == None:            self.__color =  []
        self.__color +=  [color]
        return self
    def removeColor(self, color):
        self.__color = [x for x in self.__color if x not in color]
        return self.__color
    def getColor(self, color = [1, 1, 1]):
        return self.__color
    def color_changed(self, color = [1, 1, 1]):
        return self.__color
    @property
    def direction(self):
        return self.__direction
    @direction.setter
    def direction(self, value = [0, 0, -1]):
        self.__direction = [value]
    def setDirection(self, direction = [0, 0, -1]):
        self.__direction = [direction]
        return self
    def addDirection(self, direction = [0, 0, -1]):
        if self.__direction == None:            self.__direction =  []
        self.__direction +=  [direction]
        return self
    def removeDirection(self, direction):
        self.__direction = [x for x in self.__direction if x not in direction]
        return self.__direction
    def getDirection(self, direction = [0, 0, -1]):
        return self.__direction
    def direction_changed(self, direction = [0, 0, -1]):
        return self.__direction
    @property
    def global_(self):
        return self.__global_
    @global_.setter
    def global_(self, value = False):
        self.__global_ = [value]
    def setGlobal(self, global_ = False):
        self.__global_ = [global_]
        return self
    def addGlobal(self, global_ = False):
        if self.__global_ == None:            self.__global_ =  []
        self.__global_ +=  [global_]
        return self
    def removeGlobal(self, global_):
        self.__global_ = [x for x in self.__global_ if x not in global_]
        return self.__global_
    def isGlobal(self, global_ = False):
        return self.__global_
    @property
    def intensity(self):
        return self.__intensity
    @intensity.setter
    def intensity(self, value = 1):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__intensity = [value]
    def setIntensity(self, intensity = 1):
        if intensity == None or intensity  <  0:
            return None
        if intensity == None or intensity  >  1:
            return None
        self.__intensity = [intensity]
        return self
    def addIntensity(self, intensity = 1):
        if intensity == None or intensity  <  0:
            return None
        if intensity == None or intensity  >  1:
            return None
        if self.__intensity == None:            self.__intensity =  []
        self.__intensity +=  [intensity]
        return self
    def removeIntensity(self, intensity):
        self.__intensity = [x for x in self.__intensity if x not in intensity]
        return self.__intensity
    def getIntensity(self, intensity = 1):
        return self.__intensity
    def intensity_changed(self, intensity = 1):
        return self.__intensity
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def on(self):
        return self.__on
    @on.setter
    def on(self, value = True):
        self.__on = [value]
    def setOn(self, on = True):
        self.__on = [on]
        return self
    def addOn(self, on = True):
        if self.__on == None:            self.__on =  []
        self.__on +=  [on]
        return self
    def removeOn(self, on):
        self.__on = [x for x in self.__on if x not in on]
        return self.__on
    def isOn(self, on = True):
        return self.__on
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    @property
    def IS(self):
        return self.__IS
    @IS.setter
    def IS(self, value = None):
        self.__IS = [value]
    def setIS(self, IS = None):
        self.__IS = [IS]
        return self
    def addIS(self, IS = None):
        if self.__IS == None:            self.__IS =  []
        self.__IS +=  [IS]
        return self
    def removeIS(self, IS):
        self.__IS = [x for x in self.__IS if x not in IS]
        return self.__IS
    def getIS(self, IS = None):
        return self.__IS
    def IS_changed(self, IS = None):
        return self.__IS
    def toXML(self):
        str = ''
        str += '<DirectionalLight'
        if self.__ambientIntensity is not None:
            if isinstance(self.__ambientIntensity, six.string_types):
                str += ' ambientIntensity="'+self.__ambientIntensity+'"'
            else:
                str += ' ambientIntensity="'+self.__ambientIntensity[0]+'"'
        if self.__color is not None:
            if isinstance(self.__color, six.string_types):
                str += ' color="'+self.__color+'"'
            else:
                str += ' color="'+self.__color[0]+'"'
        if self.__direction is not None:
            if isinstance(self.__direction, six.string_types):
                str += ' direction="'+self.__direction+'"'
            else:
                str += ' direction="'+self.__direction[0]+'"'
        if self.__global_ is not None:
            if isinstance(self.__global_, six.string_types):
                str += ' global_="'+self.__global_+'"'
            else:
                str += ' global_="'+self.__global_[0]+'"'
        if self.__intensity is not None:
            if isinstance(self.__intensity, six.string_types):
                str += ' intensity="'+self.__intensity+'"'
            else:
                str += ' intensity="'+self.__intensity[0]+'"'
        if self.__on is not None:
            if isinstance(self.__on, six.string_types):
                str += ' on="'+self.__on+'"'
            else:
                str += ' on="'+self.__on[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</DirectionalLight>'
        return str


class DISEntityManager(X3DChildNode):
    def __init__(self, **kwargs):
        super(DISEntityManager, self).__init__(**kwargs)
        EdEntities  = kwargs.pop("EdEntities", None)
        self.__EdEntities = EdEntities
        address  = kwargs.pop("address", "localhost")
        self.__address = address
        applicationID  = kwargs.pop("applicationID", 0)
        self.__applicationID = applicationID
        mapping  = kwargs.pop("mapping", None)
        self.__mapping = mapping
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        port  = kwargs.pop("port", 0)
        self.__port = port
        DEntities  = kwargs.pop("DEntities", None)
        self.__DEntities = DEntities
        siteID  = kwargs.pop("siteID", 0)
        self.__siteID = siteID
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def removeAddedEntities(self, EdEntities):
        self.__EdEntities = [x for x in self.__EdEntities if x not in EdEntities]
        return self.__EdEntities
    def getAddedEntities(self, EdEntities = None):
        return self.__EdEntities
    def addedEntities_changed(self, EdEntities = None):
        return self.__EdEntities
    @property
    def address(self):
        return self.__address
    @address.setter
    def address(self, value = "localhost"):
        self.__address = [value]
    def address(self, address = "localhost"):
        if self.__address == None:            self.__address =  []
        self.__address +=  [address]
        return self
    def removeAddress(self, address):
        self.__address = [x for x in self.__address if x not in address]
        return self.__address
    def getAddress(self, address = "localhost"):
        return self.__address
    def address_changed(self, address = "localhost"):
        return self.__address
    @property
    def applicationID(self):
        return self.__applicationID
    @applicationID.setter
    def applicationID(self, value = 0):
        self.__applicationID = [value]
    def setApplicationID(self, applicationID = 0):
        self.__applicationID = [applicationID]
        return self
    def addApplicationID(self, applicationID = 0):
        if self.__applicationID == None:            self.__applicationID =  []
        self.__applicationID +=  [applicationID]
        return self
    def removeApplicationID(self, applicationID):
        self.__applicationID = [x for x in self.__applicationID if x not in applicationID]
        return self.__applicationID
    def getApplicationID(self, applicationID = 0):
        return self.__applicationID
    def applicationID_changed(self, applicationID = 0):
        return self.__applicationID
    @property
    def mapping(self):
        return self.__mapping
    @mapping.setter
    def mapping(self, value = None):
        self.__mapping = [value]
    def setMapping(self, mapping = None):
        self.__mapping = [mapping]
        return self
    def addMapping(self, mapping = None):
        if self.__mapping == None:            self.__mapping =  []
        self.__mapping +=  [mapping]
        return self
    def removeMapping(self, mapping):
        self.__mapping = [x for x in self.__mapping if x not in mapping]
        return self.__mapping
    def getMapping(self, mapping = None):
        return self.__mapping
    def mapping_changed(self, mapping = None):
        return self.__mapping
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def port(self):
        return self.__port
    @port.setter
    def port(self, value = 0):
        self.__port = [value]
    def setPort(self, port = 0):
        self.__port = [port]
        return self
    def addPort(self, port = 0):
        if self.__port == None:            self.__port =  []
        self.__port +=  [port]
        return self
    def removePort(self, port):
        self.__port = [x for x in self.__port if x not in port]
        return self.__port
    def getPort(self, port = 0):
        return self.__port
    def port_changed(self, port = 0):
        return self.__port
    def removeRemovedEntities(self, DEntities):
        self.__DEntities = [x for x in self.__DEntities if x not in DEntities]
        return self.__DEntities
    def getRemovedEntities(self, DEntities = None):
        return self.__DEntities
    def removedEntities_changed(self, DEntities = None):
        return self.__DEntities
    @property
    def siteID(self):
        return self.__siteID
    @siteID.setter
    def siteID(self, value = 0):
        self.__siteID = [value]
    def setSiteID(self, siteID = 0):
        self.__siteID = [siteID]
        return self
    def addSiteID(self, siteID = 0):
        if self.__siteID == None:            self.__siteID =  []
        self.__siteID +=  [siteID]
        return self
    def removeSiteID(self, siteID):
        self.__siteID = [x for x in self.__siteID if x not in siteID]
        return self.__siteID
    def getSiteID(self, siteID = 0):
        return self.__siteID
    def siteID_changed(self, siteID = 0):
        return self.__siteID
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<DISEntityManager'
        if self.__address is not None:
            if isinstance(self.__address, six.string_types):
                str += ' address="'+self.__address+'"'
            else:
                str += ' address="'+self.__address[0]+'"'
        if self.__applicationID is not None:
            if isinstance(self.__applicationID, six.string_types):
                str += ' applicationID="'+self.__applicationID+'"'
            else:
                str += ' applicationID="'+self.__applicationID[0]+'"'
        if self.__port is not None:
            if isinstance(self.__port, six.string_types):
                str += ' port="'+self.__port+'"'
            else:
                str += ' port="'+self.__port[0]+'"'
        if self.__siteID is not None:
            if isinstance(self.__siteID, six.string_types):
                str += ' siteID="'+self.__siteID+'"'
            else:
                str += ' siteID="'+self.__siteID[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<EdEntities'
        if self.__EdEntities is not None:
           for s in self.__EdEntities:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__EdEntities is not None:
           for s in self.__EdEntities:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</EdEntities>'
        str += '<mapping'
        if self.__mapping is not None:
           for s in self.__mapping:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__mapping is not None:
           for s in self.__mapping:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</mapping>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<DEntities'
        if self.__DEntities is not None:
           for s in self.__DEntities:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__DEntities is not None:
           for s in self.__DEntities:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</DEntities>'
        str += '</DISEntityManager>'
        return str


class DISEntityTypeMapping(X3DUrlObject, X3DInfoNode):
    def __init__(self, **kwargs):
        super(DISEntityTypeMapping, self).__init__(**kwargs)
        category  = kwargs.pop("category", 0)
        if category == None or category  <  0:
            return None
        if category == None or category  >  255:
            return None
        self.__category = category
        country  = kwargs.pop("country", 0)
        if country == None or country  <  0:
            return None
        if country == None or country  >  65535:
            return None
        self.__country = country
        domain  = kwargs.pop("domain", 0)
        if domain == None or domain  <  0:
            return None
        if domain == None or domain  >  255:
            return None
        self.__domain = domain
        extra  = kwargs.pop("extra", 0)
        if extra == None or extra  <  0:
            return None
        if extra == None or extra  >  255:
            return None
        self.__extra = extra
        kind  = kwargs.pop("kind", 0)
        if kind == None or kind  <  0:
            return None
        if kind == None or kind  >  255:
            return None
        self.__kind = kind
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        specific  = kwargs.pop("specific", 0)
        if specific == None or specific  <  0:
            return None
        if specific == None or specific  >  255:
            return None
        self.__specific = specific
        subcategory  = kwargs.pop("subcategory", 0)
        if subcategory == None or subcategory  <  0:
            return None
        if subcategory == None or subcategory  >  255:
            return None
        self.__subcategory = subcategory
        url  = kwargs.pop("url", None)
        self.__url = url
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def url(self):
        return self.__url
    @url.setter
    def url(self, value = None):
        self.__url = [value]
    def setUrl(self, url = None):
        self.__url = [url]
        return self
    def addUrl(self, url = None):
        if self.__url == None:            self.__url =  []
        self.__url +=  [url]
        return self
    def removeUrl(self, url):
        self.__url = [x for x in self.__url if x not in url]
        return self.__url
    def getUrl(self, url = None):
        return self.__url
    def url_changed(self, url = None):
        return self.__url
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<DISEntityTypeMapping'
        if self.__category is not None:
            if isinstance(self.__category, six.string_types):
                str += ' category="'+self.__category+'"'
            else:
                str += ' category="'+self.__category[0]+'"'
        if self.__country is not None:
            if isinstance(self.__country, six.string_types):
                str += ' country="'+self.__country+'"'
            else:
                str += ' country="'+self.__country[0]+'"'
        if self.__domain is not None:
            if isinstance(self.__domain, six.string_types):
                str += ' domain="'+self.__domain+'"'
            else:
                str += ' domain="'+self.__domain[0]+'"'
        if self.__extra is not None:
            if isinstance(self.__extra, six.string_types):
                str += ' extra="'+self.__extra+'"'
            else:
                str += ' extra="'+self.__extra[0]+'"'
        if self.__kind is not None:
            if isinstance(self.__kind, six.string_types):
                str += ' kind="'+self.__kind+'"'
            else:
                str += ' kind="'+self.__kind[0]+'"'
        if self.__specific is not None:
            if isinstance(self.__specific, six.string_types):
                str += ' specific="'+self.__specific+'"'
            else:
                str += ' specific="'+self.__specific[0]+'"'
        if self.__subcategory is not None:
            if isinstance(self.__subcategory, six.string_types):
                str += ' subcategory="'+self.__subcategory+'"'
            else:
                str += ' subcategory="'+self.__subcategory[0]+'"'
        if self.__url is not None:
            if isinstance(self.__url, six.string_types):
                str += ' url="'+self.__url+'"'
            else:
                str += ' url="'+self.__url[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</DISEntityTypeMapping>'
        return str


class Disk2D(X3DGeometryNode):
    def __init__(self, **kwargs):
        super(Disk2D, self).__init__(**kwargs)
        innerRadius  = kwargs.pop("innerRadius", 0)
        if innerRadius == None or innerRadius  <  0:
            return None
        self.__innerRadius = innerRadius
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        outerRadius  = kwargs.pop("outerRadius", 1)
        if outerRadius == None or outerRadius  <=  0:
            return None
        self.__outerRadius = outerRadius
        solid  = kwargs.pop("solid", False)
        self.__solid = solid
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Disk2D'
        if self.__innerRadius is not None:
            if isinstance(self.__innerRadius, six.string_types):
                str += ' innerRadius="'+self.__innerRadius+'"'
            else:
                str += ' innerRadius="'+self.__innerRadius[0]+'"'
        if self.__outerRadius is not None:
            if isinstance(self.__outerRadius, six.string_types):
                str += ' outerRadius="'+self.__outerRadius+'"'
            else:
                str += ' outerRadius="'+self.__outerRadius[0]+'"'
        if self.__solid is not None:
            if isinstance(self.__solid, six.string_types):
                str += ' solid="'+self.__solid+'"'
            else:
                str += ' solid="'+self.__solid[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</Disk2D>'
        return str


class DoubleAxisHingeJoint(X3DRigidJointNode):
    def __init__(self, **kwargs):
        super(DoubleAxisHingeJoint, self).__init__(**kwargs)
        anchorPoint  = kwargs.pop("anchorPoint", [0, 0, 0])
        self.__anchorPoint = anchorPoint
        axis1  = kwargs.pop("axis1", [0, 0, 0])
        self.__axis1 = axis1
        axis2  = kwargs.pop("axis2", [0, 0, 0])
        self.__axis2 = axis2
        body1  = kwargs.pop("body1", None)
        self.__body1 = body1
        body1AnchorPoint  = kwargs.pop("body1AnchorPoint", None)
        self.__body1AnchorPoint = body1AnchorPoint
        body1Axis  = kwargs.pop("body1Axis", None)
        self.__body1Axis = body1Axis
        body2  = kwargs.pop("body2", None)
        self.__body2 = body2
        body2AnchorPoint  = kwargs.pop("body2AnchorPoint", None)
        self.__body2AnchorPoint = body2AnchorPoint
        body2Axis  = kwargs.pop("body2Axis", None)
        self.__body2Axis = body2Axis
        desiredAngularVelocity1  = kwargs.pop("desiredAngularVelocity1", 0)
        self.__desiredAngularVelocity1 = desiredAngularVelocity1
        desiredAngularVelocity2  = kwargs.pop("desiredAngularVelocity2", 0)
        self.__desiredAngularVelocity2 = desiredAngularVelocity2
        forceOutput  = kwargs.pop("forceOutput", ["NONE"])
        self.__forceOutput = forceOutput
        hinge1Angle  = kwargs.pop("hinge1Angle", None)
        self.__hinge1Angle = hinge1Angle
        hinge1AngleRate  = kwargs.pop("hinge1AngleRate", None)
        self.__hinge1AngleRate = hinge1AngleRate
        hinge2Angle  = kwargs.pop("hinge2Angle", None)
        self.__hinge2Angle = hinge2Angle
        hinge2AngleRate  = kwargs.pop("hinge2AngleRate", None)
        self.__hinge2AngleRate = hinge2AngleRate
        maxAngle1  = kwargs.pop("maxAngle1", 3.141592653)
        self.__maxAngle1 = maxAngle1
        maxTorque1  = kwargs.pop("maxTorque1", 0)
        self.__maxTorque1 = maxTorque1
        maxTorque2  = kwargs.pop("maxTorque2", 0)
        self.__maxTorque2 = maxTorque2
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        minAngle1  = kwargs.pop("minAngle1", -3.141592653)
        self.__minAngle1 = minAngle1
        stop1Bounce  = kwargs.pop("stop1Bounce", 0)
        self.__stop1Bounce = stop1Bounce
        stop1ConstantForceMix  = kwargs.pop("stop1ConstantForceMix", 0.001)
        self.__stop1ConstantForceMix = stop1ConstantForceMix
        stop1ErrorCorrection  = kwargs.pop("stop1ErrorCorrection", 0.8)
        self.__stop1ErrorCorrection = stop1ErrorCorrection
        suspensionErrorCorrection  = kwargs.pop("suspensionErrorCorrection", 0.8)
        self.__suspensionErrorCorrection = suspensionErrorCorrection
        suspensionForce  = kwargs.pop("suspensionForce", 0)
        self.__suspensionForce = suspensionForce
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def anchorPoint(self):
        return self.__anchorPoint
    @anchorPoint.setter
    def anchorPoint(self, value = [0, 0, 0]):
        self.__anchorPoint = [value]
    def setAnchorPoint(self, anchorPoint = [0, 0, 0]):
        self.__anchorPoint = [anchorPoint]
        return self
    def addAnchorPoint(self, anchorPoint = [0, 0, 0]):
        if self.__anchorPoint == None:            self.__anchorPoint =  []
        self.__anchorPoint +=  [anchorPoint]
        return self
    def removeAnchorPoint(self, anchorPoint):
        self.__anchorPoint = [x for x in self.__anchorPoint if x not in anchorPoint]
        return self.__anchorPoint
    def getAnchorPoint(self, anchorPoint = [0, 0, 0]):
        return self.__anchorPoint
    def anchorPoint_changed(self, anchorPoint = [0, 0, 0]):
        return self.__anchorPoint
    @property
    def axis1(self):
        return self.__axis1
    @axis1.setter
    def axis1(self, value = [0, 0, 0]):
        self.__axis1 = [value]
    def setAxis1(self, axis1 = [0, 0, 0]):
        self.__axis1 = [axis1]
        return self
    def addAxis1(self, axis1 = [0, 0, 0]):
        if self.__axis1 == None:            self.__axis1 =  []
        self.__axis1 +=  [axis1]
        return self
    def removeAxis1(self, axis1):
        self.__axis1 = [x for x in self.__axis1 if x not in axis1]
        return self.__axis1
    def getAxis1(self, axis1 = [0, 0, 0]):
        return self.__axis1
    def axis1_changed(self, axis1 = [0, 0, 0]):
        return self.__axis1
    @property
    def axis2(self):
        return self.__axis2
    @axis2.setter
    def axis2(self, value = [0, 0, 0]):
        self.__axis2 = [value]
    def setAxis2(self, axis2 = [0, 0, 0]):
        self.__axis2 = [axis2]
        return self
    def addAxis2(self, axis2 = [0, 0, 0]):
        if self.__axis2 == None:            self.__axis2 =  []
        self.__axis2 +=  [axis2]
        return self
    def removeAxis2(self, axis2):
        self.__axis2 = [x for x in self.__axis2 if x not in axis2]
        return self.__axis2
    def getAxis2(self, axis2 = [0, 0, 0]):
        return self.__axis2
    def axis2_changed(self, axis2 = [0, 0, 0]):
        return self.__axis2
    @property
    def body1(self):
        return self.__body1
    @body1.setter
    def body1(self, value = None):
        self.__body1 = [value]
    def setBody1(self, body1 = None):
        self.__body1 = [body1]
        return self
    def addBody1(self, body1 = None):
        if self.__body1 == None:            self.__body1 =  []
        self.__body1 +=  [body1]
        return self
    def removeBody1(self, body1):
        self.__body1 = [x for x in self.__body1 if x not in body1]
        return self.__body1
    def getBody1(self, body1 = None):
        return self.__body1
    def body1_changed(self, body1 = None):
        return self.__body1
    def removeBody1AnchorPoint(self, body1AnchorPoint):
        self.__body1AnchorPoint = [x for x in self.__body1AnchorPoint if x not in body1AnchorPoint]
        return self.__body1AnchorPoint
    def getBody1AnchorPoint(self, body1AnchorPoint = None):
        return self.__body1AnchorPoint
    def body1AnchorPoint_changed(self, body1AnchorPoint = None):
        return self.__body1AnchorPoint
    def removeBody1Axis(self, body1Axis):
        self.__body1Axis = [x for x in self.__body1Axis if x not in body1Axis]
        return self.__body1Axis
    def getBody1Axis(self, body1Axis = None):
        return self.__body1Axis
    def body1Axis_changed(self, body1Axis = None):
        return self.__body1Axis
    @property
    def body2(self):
        return self.__body2
    @body2.setter
    def body2(self, value = None):
        self.__body2 = [value]
    def setBody2(self, body2 = None):
        self.__body2 = [body2]
        return self
    def addBody2(self, body2 = None):
        if self.__body2 == None:            self.__body2 =  []
        self.__body2 +=  [body2]
        return self
    def removeBody2(self, body2):
        self.__body2 = [x for x in self.__body2 if x not in body2]
        return self.__body2
    def getBody2(self, body2 = None):
        return self.__body2
    def body2_changed(self, body2 = None):
        return self.__body2
    def removeBody2AnchorPoint(self, body2AnchorPoint):
        self.__body2AnchorPoint = [x for x in self.__body2AnchorPoint if x not in body2AnchorPoint]
        return self.__body2AnchorPoint
    def getBody2AnchorPoint(self, body2AnchorPoint = None):
        return self.__body2AnchorPoint
    def body2AnchorPoint_changed(self, body2AnchorPoint = None):
        return self.__body2AnchorPoint
    def removeBody2Axis(self, body2Axis):
        self.__body2Axis = [x for x in self.__body2Axis if x not in body2Axis]
        return self.__body2Axis
    def getBody2Axis(self, body2Axis = None):
        return self.__body2Axis
    def body2Axis_changed(self, body2Axis = None):
        return self.__body2Axis
    @property
    def desiredAngularVelocity1(self):
        return self.__desiredAngularVelocity1
    @desiredAngularVelocity1.setter
    def desiredAngularVelocity1(self, value = 0):
        self.__desiredAngularVelocity1 = [value]
    def setDesiredAngularVelocity1(self, desiredAngularVelocity1 = 0):
        self.__desiredAngularVelocity1 = [desiredAngularVelocity1]
        return self
    def addDesiredAngularVelocity1(self, desiredAngularVelocity1 = 0):
        if self.__desiredAngularVelocity1 == None:            self.__desiredAngularVelocity1 =  []
        self.__desiredAngularVelocity1 +=  [desiredAngularVelocity1]
        return self
    def removeDesiredAngularVelocity1(self, desiredAngularVelocity1):
        self.__desiredAngularVelocity1 = [x for x in self.__desiredAngularVelocity1 if x not in desiredAngularVelocity1]
        return self.__desiredAngularVelocity1
    def getDesiredAngularVelocity1(self, desiredAngularVelocity1 = 0):
        return self.__desiredAngularVelocity1
    def desiredAngularVelocity1_changed(self, desiredAngularVelocity1 = 0):
        return self.__desiredAngularVelocity1
    @property
    def desiredAngularVelocity2(self):
        return self.__desiredAngularVelocity2
    @desiredAngularVelocity2.setter
    def desiredAngularVelocity2(self, value = 0):
        self.__desiredAngularVelocity2 = [value]
    def setDesiredAngularVelocity2(self, desiredAngularVelocity2 = 0):
        self.__desiredAngularVelocity2 = [desiredAngularVelocity2]
        return self
    def addDesiredAngularVelocity2(self, desiredAngularVelocity2 = 0):
        if self.__desiredAngularVelocity2 == None:            self.__desiredAngularVelocity2 =  []
        self.__desiredAngularVelocity2 +=  [desiredAngularVelocity2]
        return self
    def removeDesiredAngularVelocity2(self, desiredAngularVelocity2):
        self.__desiredAngularVelocity2 = [x for x in self.__desiredAngularVelocity2 if x not in desiredAngularVelocity2]
        return self.__desiredAngularVelocity2
    def getDesiredAngularVelocity2(self, desiredAngularVelocity2 = 0):
        return self.__desiredAngularVelocity2
    def desiredAngularVelocity2_changed(self, desiredAngularVelocity2 = 0):
        return self.__desiredAngularVelocity2
    @property
    def forceOutput(self):
        return self.__forceOutput
    @forceOutput.setter
    def forceOutput(self, value = ["NONE"]):
        self.__forceOutput = [value]
    def setForceOutput(self, forceOutput = ["NONE"]):
        self.__forceOutput = [forceOutput]
        return self
    def addForceOutput(self, forceOutput = ["NONE"]):
        if self.__forceOutput == None:            self.__forceOutput =  []
        self.__forceOutput +=  [forceOutput]
        return self
    def removeForceOutput(self, forceOutput):
        self.__forceOutput = [x for x in self.__forceOutput if x not in forceOutput]
        return self.__forceOutput
    def getForceOutput(self, forceOutput = ["NONE"]):
        return self.__forceOutput
    def forceOutput_changed(self, forceOutput = ["NONE"]):
        return self.__forceOutput
    def removeHinge1Angle(self, hinge1Angle):
        self.__hinge1Angle = [x for x in self.__hinge1Angle if x not in hinge1Angle]
        return self.__hinge1Angle
    def getHinge1Angle(self, hinge1Angle = None):
        return self.__hinge1Angle
    def hinge1Angle_changed(self, hinge1Angle = None):
        return self.__hinge1Angle
    def removeHinge1AngleRate(self, hinge1AngleRate):
        self.__hinge1AngleRate = [x for x in self.__hinge1AngleRate if x not in hinge1AngleRate]
        return self.__hinge1AngleRate
    def getHinge1AngleRate(self, hinge1AngleRate = None):
        return self.__hinge1AngleRate
    def hinge1AngleRate_changed(self, hinge1AngleRate = None):
        return self.__hinge1AngleRate
    def removeHinge2Angle(self, hinge2Angle):
        self.__hinge2Angle = [x for x in self.__hinge2Angle if x not in hinge2Angle]
        return self.__hinge2Angle
    def getHinge2Angle(self, hinge2Angle = None):
        return self.__hinge2Angle
    def hinge2Angle_changed(self, hinge2Angle = None):
        return self.__hinge2Angle
    def removeHinge2AngleRate(self, hinge2AngleRate):
        self.__hinge2AngleRate = [x for x in self.__hinge2AngleRate if x not in hinge2AngleRate]
        return self.__hinge2AngleRate
    def getHinge2AngleRate(self, hinge2AngleRate = None):
        return self.__hinge2AngleRate
    def hinge2AngleRate_changed(self, hinge2AngleRate = None):
        return self.__hinge2AngleRate
    @property
    def maxAngle1(self):
        return self.__maxAngle1
    @maxAngle1.setter
    def maxAngle1(self, value = 3.141592653):
        self.__maxAngle1 = [value]
    def setMaxAngle1(self, maxAngle1 = 3.141592653):
        self.__maxAngle1 = [maxAngle1]
        return self
    def addMaxAngle1(self, maxAngle1 = 3.141592653):
        if self.__maxAngle1 == None:            self.__maxAngle1 =  []
        self.__maxAngle1 +=  [maxAngle1]
        return self
    def removeMaxAngle1(self, maxAngle1):
        self.__maxAngle1 = [x for x in self.__maxAngle1 if x not in maxAngle1]
        return self.__maxAngle1
    def getMaxAngle1(self, maxAngle1 = 3.141592653):
        return self.__maxAngle1
    def maxAngle1_changed(self, maxAngle1 = 3.141592653):
        return self.__maxAngle1
    @property
    def maxTorque1(self):
        return self.__maxTorque1
    @maxTorque1.setter
    def maxTorque1(self, value = 0):
        self.__maxTorque1 = [value]
    def setMaxTorque1(self, maxTorque1 = 0):
        self.__maxTorque1 = [maxTorque1]
        return self
    def addMaxTorque1(self, maxTorque1 = 0):
        if self.__maxTorque1 == None:            self.__maxTorque1 =  []
        self.__maxTorque1 +=  [maxTorque1]
        return self
    def removeMaxTorque1(self, maxTorque1):
        self.__maxTorque1 = [x for x in self.__maxTorque1 if x not in maxTorque1]
        return self.__maxTorque1
    def getMaxTorque1(self, maxTorque1 = 0):
        return self.__maxTorque1
    def maxTorque1_changed(self, maxTorque1 = 0):
        return self.__maxTorque1
    @property
    def maxTorque2(self):
        return self.__maxTorque2
    @maxTorque2.setter
    def maxTorque2(self, value = 0):
        self.__maxTorque2 = [value]
    def setMaxTorque2(self, maxTorque2 = 0):
        self.__maxTorque2 = [maxTorque2]
        return self
    def addMaxTorque2(self, maxTorque2 = 0):
        if self.__maxTorque2 == None:            self.__maxTorque2 =  []
        self.__maxTorque2 +=  [maxTorque2]
        return self
    def removeMaxTorque2(self, maxTorque2):
        self.__maxTorque2 = [x for x in self.__maxTorque2 if x not in maxTorque2]
        return self.__maxTorque2
    def getMaxTorque2(self, maxTorque2 = 0):
        return self.__maxTorque2
    def maxTorque2_changed(self, maxTorque2 = 0):
        return self.__maxTorque2
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def minAngle1(self):
        return self.__minAngle1
    @minAngle1.setter
    def minAngle1(self, value = -3.141592653):
        self.__minAngle1 = [value]
    def setMinAngle1(self, minAngle1 = -3.141592653):
        self.__minAngle1 = [minAngle1]
        return self
    def addMinAngle1(self, minAngle1 = -3.141592653):
        if self.__minAngle1 == None:            self.__minAngle1 =  []
        self.__minAngle1 +=  [minAngle1]
        return self
    def removeMinAngle1(self, minAngle1):
        self.__minAngle1 = [x for x in self.__minAngle1 if x not in minAngle1]
        return self.__minAngle1
    def getMinAngle1(self, minAngle1 = -3.141592653):
        return self.__minAngle1
    def minAngle1_changed(self, minAngle1 = -3.141592653):
        return self.__minAngle1
    @property
    def stop1Bounce(self):
        return self.__stop1Bounce
    @stop1Bounce.setter
    def stop1Bounce(self, value = 0):
        self.__stop1Bounce = [value]
    def setStop1Bounce(self, stop1Bounce = 0):
        self.__stop1Bounce = [stop1Bounce]
        return self
    def addStop1Bounce(self, stop1Bounce = 0):
        if self.__stop1Bounce == None:            self.__stop1Bounce =  []
        self.__stop1Bounce +=  [stop1Bounce]
        return self
    def removeStop1Bounce(self, stop1Bounce):
        self.__stop1Bounce = [x for x in self.__stop1Bounce if x not in stop1Bounce]
        return self.__stop1Bounce
    def getStop1Bounce(self, stop1Bounce = 0):
        return self.__stop1Bounce
    def stop1Bounce_changed(self, stop1Bounce = 0):
        return self.__stop1Bounce
    @property
    def stop1ConstantForceMix(self):
        return self.__stop1ConstantForceMix
    @stop1ConstantForceMix.setter
    def stop1ConstantForceMix(self, value = 0.001):
        self.__stop1ConstantForceMix = [value]
    def setStop1ConstantForceMix(self, stop1ConstantForceMix = 0.001):
        self.__stop1ConstantForceMix = [stop1ConstantForceMix]
        return self
    def addStop1ConstantForceMix(self, stop1ConstantForceMix = 0.001):
        if self.__stop1ConstantForceMix == None:            self.__stop1ConstantForceMix =  []
        self.__stop1ConstantForceMix +=  [stop1ConstantForceMix]
        return self
    def removeStop1ConstantForceMix(self, stop1ConstantForceMix):
        self.__stop1ConstantForceMix = [x for x in self.__stop1ConstantForceMix if x not in stop1ConstantForceMix]
        return self.__stop1ConstantForceMix
    def getStop1ConstantForceMix(self, stop1ConstantForceMix = 0.001):
        return self.__stop1ConstantForceMix
    def stop1ConstantForceMix_changed(self, stop1ConstantForceMix = 0.001):
        return self.__stop1ConstantForceMix
    @property
    def stop1ErrorCorrection(self):
        return self.__stop1ErrorCorrection
    @stop1ErrorCorrection.setter
    def stop1ErrorCorrection(self, value = 0.8):
        self.__stop1ErrorCorrection = [value]
    def setStop1ErrorCorrection(self, stop1ErrorCorrection = 0.8):
        self.__stop1ErrorCorrection = [stop1ErrorCorrection]
        return self
    def addStop1ErrorCorrection(self, stop1ErrorCorrection = 0.8):
        if self.__stop1ErrorCorrection == None:            self.__stop1ErrorCorrection =  []
        self.__stop1ErrorCorrection +=  [stop1ErrorCorrection]
        return self
    def removeStop1ErrorCorrection(self, stop1ErrorCorrection):
        self.__stop1ErrorCorrection = [x for x in self.__stop1ErrorCorrection if x not in stop1ErrorCorrection]
        return self.__stop1ErrorCorrection
    def getStop1ErrorCorrection(self, stop1ErrorCorrection = 0.8):
        return self.__stop1ErrorCorrection
    def stop1ErrorCorrection_changed(self, stop1ErrorCorrection = 0.8):
        return self.__stop1ErrorCorrection
    @property
    def suspensionErrorCorrection(self):
        return self.__suspensionErrorCorrection
    @suspensionErrorCorrection.setter
    def suspensionErrorCorrection(self, value = 0.8):
        self.__suspensionErrorCorrection = [value]
    def setSuspensionErrorCorrection(self, suspensionErrorCorrection = 0.8):
        self.__suspensionErrorCorrection = [suspensionErrorCorrection]
        return self
    def addSuspensionErrorCorrection(self, suspensionErrorCorrection = 0.8):
        if self.__suspensionErrorCorrection == None:            self.__suspensionErrorCorrection =  []
        self.__suspensionErrorCorrection +=  [suspensionErrorCorrection]
        return self
    def removeSuspensionErrorCorrection(self, suspensionErrorCorrection):
        self.__suspensionErrorCorrection = [x for x in self.__suspensionErrorCorrection if x not in suspensionErrorCorrection]
        return self.__suspensionErrorCorrection
    def getSuspensionErrorCorrection(self, suspensionErrorCorrection = 0.8):
        return self.__suspensionErrorCorrection
    def suspensionErrorCorrection_changed(self, suspensionErrorCorrection = 0.8):
        return self.__suspensionErrorCorrection
    @property
    def suspensionForce(self):
        return self.__suspensionForce
    @suspensionForce.setter
    def suspensionForce(self, value = 0):
        self.__suspensionForce = [value]
    def setSuspensionForce(self, suspensionForce = 0):
        self.__suspensionForce = [suspensionForce]
        return self
    def addSuspensionForce(self, suspensionForce = 0):
        if self.__suspensionForce == None:            self.__suspensionForce =  []
        self.__suspensionForce +=  [suspensionForce]
        return self
    def removeSuspensionForce(self, suspensionForce):
        self.__suspensionForce = [x for x in self.__suspensionForce if x not in suspensionForce]
        return self.__suspensionForce
    def getSuspensionForce(self, suspensionForce = 0):
        return self.__suspensionForce
    def suspensionForce_changed(self, suspensionForce = 0):
        return self.__suspensionForce
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<DoubleAxisHingeJoint'
        if self.__anchorPoint is not None:
            if isinstance(self.__anchorPoint, six.string_types):
                str += ' anchorPoint="'+self.__anchorPoint+'"'
            else:
                str += ' anchorPoint="'+self.__anchorPoint[0]+'"'
        if self.__axis1 is not None:
            if isinstance(self.__axis1, six.string_types):
                str += ' axis1="'+self.__axis1+'"'
            else:
                str += ' axis1="'+self.__axis1[0]+'"'
        if self.__axis2 is not None:
            if isinstance(self.__axis2, six.string_types):
                str += ' axis2="'+self.__axis2+'"'
            else:
                str += ' axis2="'+self.__axis2[0]+'"'
        if self.__body1AnchorPoint is not None:
            if isinstance(self.__body1AnchorPoint, six.string_types):
                str += ' body1AnchorPoint="'+self.__body1AnchorPoint+'"'
            else:
                str += ' body1AnchorPoint="'+self.__body1AnchorPoint[0]+'"'
        if self.__body1Axis is not None:
            if isinstance(self.__body1Axis, six.string_types):
                str += ' body1Axis="'+self.__body1Axis+'"'
            else:
                str += ' body1Axis="'+self.__body1Axis[0]+'"'
        if self.__body2AnchorPoint is not None:
            if isinstance(self.__body2AnchorPoint, six.string_types):
                str += ' body2AnchorPoint="'+self.__body2AnchorPoint+'"'
            else:
                str += ' body2AnchorPoint="'+self.__body2AnchorPoint[0]+'"'
        if self.__body2Axis is not None:
            if isinstance(self.__body2Axis, six.string_types):
                str += ' body2Axis="'+self.__body2Axis+'"'
            else:
                str += ' body2Axis="'+self.__body2Axis[0]+'"'
        if self.__desiredAngularVelocity1 is not None:
            if isinstance(self.__desiredAngularVelocity1, six.string_types):
                str += ' desiredAngularVelocity1="'+self.__desiredAngularVelocity1+'"'
            else:
                str += ' desiredAngularVelocity1="'+self.__desiredAngularVelocity1[0]+'"'
        if self.__desiredAngularVelocity2 is not None:
            if isinstance(self.__desiredAngularVelocity2, six.string_types):
                str += ' desiredAngularVelocity2="'+self.__desiredAngularVelocity2+'"'
            else:
                str += ' desiredAngularVelocity2="'+self.__desiredAngularVelocity2[0]+'"'
        if self.__forceOutput is not None:
            if isinstance(self.__forceOutput, six.string_types):
                str += ' forceOutput="'+self.__forceOutput+'"'
            else:
                str += ' forceOutput="'+self.__forceOutput[0]+'"'
        if self.__hinge1Angle is not None:
            if isinstance(self.__hinge1Angle, six.string_types):
                str += ' hinge1Angle="'+self.__hinge1Angle+'"'
            else:
                str += ' hinge1Angle="'+self.__hinge1Angle[0]+'"'
        if self.__hinge1AngleRate is not None:
            if isinstance(self.__hinge1AngleRate, six.string_types):
                str += ' hinge1AngleRate="'+self.__hinge1AngleRate+'"'
            else:
                str += ' hinge1AngleRate="'+self.__hinge1AngleRate[0]+'"'
        if self.__hinge2Angle is not None:
            if isinstance(self.__hinge2Angle, six.string_types):
                str += ' hinge2Angle="'+self.__hinge2Angle+'"'
            else:
                str += ' hinge2Angle="'+self.__hinge2Angle[0]+'"'
        if self.__hinge2AngleRate is not None:
            if isinstance(self.__hinge2AngleRate, six.string_types):
                str += ' hinge2AngleRate="'+self.__hinge2AngleRate+'"'
            else:
                str += ' hinge2AngleRate="'+self.__hinge2AngleRate[0]+'"'
        if self.__maxAngle1 is not None:
            if isinstance(self.__maxAngle1, six.string_types):
                str += ' maxAngle1="'+self.__maxAngle1+'"'
            else:
                str += ' maxAngle1="'+self.__maxAngle1[0]+'"'
        if self.__maxTorque1 is not None:
            if isinstance(self.__maxTorque1, six.string_types):
                str += ' maxTorque1="'+self.__maxTorque1+'"'
            else:
                str += ' maxTorque1="'+self.__maxTorque1[0]+'"'
        if self.__maxTorque2 is not None:
            if isinstance(self.__maxTorque2, six.string_types):
                str += ' maxTorque2="'+self.__maxTorque2+'"'
            else:
                str += ' maxTorque2="'+self.__maxTorque2[0]+'"'
        if self.__minAngle1 is not None:
            if isinstance(self.__minAngle1, six.string_types):
                str += ' minAngle1="'+self.__minAngle1+'"'
            else:
                str += ' minAngle1="'+self.__minAngle1[0]+'"'
        if self.__stop1Bounce is not None:
            if isinstance(self.__stop1Bounce, six.string_types):
                str += ' stop1Bounce="'+self.__stop1Bounce+'"'
            else:
                str += ' stop1Bounce="'+self.__stop1Bounce[0]+'"'
        if self.__stop1ConstantForceMix is not None:
            if isinstance(self.__stop1ConstantForceMix, six.string_types):
                str += ' stop1ConstantForceMix="'+self.__stop1ConstantForceMix+'"'
            else:
                str += ' stop1ConstantForceMix="'+self.__stop1ConstantForceMix[0]+'"'
        if self.__stop1ErrorCorrection is not None:
            if isinstance(self.__stop1ErrorCorrection, six.string_types):
                str += ' stop1ErrorCorrection="'+self.__stop1ErrorCorrection+'"'
            else:
                str += ' stop1ErrorCorrection="'+self.__stop1ErrorCorrection[0]+'"'
        if self.__suspensionErrorCorrection is not None:
            if isinstance(self.__suspensionErrorCorrection, six.string_types):
                str += ' suspensionErrorCorrection="'+self.__suspensionErrorCorrection+'"'
            else:
                str += ' suspensionErrorCorrection="'+self.__suspensionErrorCorrection[0]+'"'
        if self.__suspensionForce is not None:
            if isinstance(self.__suspensionForce, six.string_types):
                str += ' suspensionForce="'+self.__suspensionForce+'"'
            else:
                str += ' suspensionForce="'+self.__suspensionForce[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<body1'
        if self.__body1 is not None:
           for s in self.__body1:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__body1 is not None:
           for s in self.__body1:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</body1>'
        str += '<body2'
        if self.__body2 is not None:
           for s in self.__body2:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__body2 is not None:
           for s in self.__body2:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</body2>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</DoubleAxisHingeJoint>'
        return str


class EaseInEaseOut(X3DChildNode):
    def __init__(self, **kwargs):
        super(EaseInEaseOut, self).__init__(**kwargs)
        easeInEaseOut  = kwargs.pop("easeInEaseOut", None)
        self.__easeInEaseOut = easeInEaseOut
        key  = kwargs.pop("key", None)
        self.__key = key
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        modifiedFraction_changed  = kwargs.pop("modifiedFraction_changed", None)
        self.__modifiedFraction_changed = modifiedFraction_changed
        fraction  = kwargs.pop("fraction", None)
        self.__fraction = fraction
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def easeInEaseOut(self):
        return self.__easeInEaseOut
    @easeInEaseOut.setter
    def easeInEaseOut(self, value = None):
        self.__easeInEaseOut = [value]
    def setEaseInEaseOut(self, easeInEaseOut = None):
        self.__easeInEaseOut = [easeInEaseOut]
        return self
    def addEaseInEaseOut(self, easeInEaseOut = None):
        if self.__easeInEaseOut == None:            self.__easeInEaseOut =  []
        self.__easeInEaseOut +=  [easeInEaseOut]
        return self
    def removeEaseInEaseOut(self, easeInEaseOut):
        self.__easeInEaseOut = [x for x in self.__easeInEaseOut if x not in easeInEaseOut]
        return self.__easeInEaseOut
    def getEaseInEaseOut(self, easeInEaseOut = None):
        return self.__easeInEaseOut
    def easeInEaseOut_changed(self, easeInEaseOut = None):
        return self.__easeInEaseOut
    @property
    def key(self):
        return self.__key
    @key.setter
    def key(self, value = None):
        self.__key = [value]
    def setKey(self, key = None):
        self.__key = [key]
        return self
    def addKey(self, key = None):
        if self.__key == None:            self.__key =  []
        self.__key +=  [key]
        return self
    def removeKey(self, key):
        self.__key = [x for x in self.__key if x not in key]
        return self.__key
    def getKey(self, key = None):
        return self.__key
    def key_changed(self, key = None):
        return self.__key
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    def removemodifiedFraction_changed(self, modifiedFraction_changed):
        self.__modifiedFraction_changed = [x for x in self.__modifiedFraction_changed if x not in modifiedFraction_changed]
        return self.__modifiedFraction_changed
    def getmodifiedFraction_changed(self, modifiedFraction_changed = None):
        return self.__modifiedFraction_changed
    def modifiedFraction_changed_changed(self, modifiedFraction_changed = None):
        return self.__modifiedFraction_changed
    @property
    def fraction(self):
        return self.__fraction
    @fraction.setter
    def fraction(self, value = None):
        self.__fraction = [value]
    def set_fraction(self, fraction = None):
        self.__fraction = [fraction]
        return self
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<EaseInEaseOut'
        if self.__easeInEaseOut is not None:
            if isinstance(self.__easeInEaseOut, six.string_types):
                str += ' easeInEaseOut="'+self.__easeInEaseOut+'"'
            else:
                str += ' easeInEaseOut="'+self.__easeInEaseOut[0]+'"'
        if self.__key is not None:
            if isinstance(self.__key, six.string_types):
                str += ' key="'+self.__key+'"'
            else:
                str += ' key="'+self.__key[0]+'"'
        if self.__modifiedFraction_changed is not None:
            if isinstance(self.__modifiedFraction_changed, six.string_types):
                str += ' modifiedFraction_changed="'+self.__modifiedFraction_changed+'"'
            else:
                str += ' modifiedFraction_changed="'+self.__modifiedFraction_changed[0]+'"'
        if self.__fraction is not None:
            if isinstance(self.__fraction, six.string_types):
                str += ' fraction="'+self.__fraction+'"'
            else:
                str += ' fraction="'+self.__fraction[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</EaseInEaseOut>'
        return str


class EdgeEnhancementVolumeStyle(X3DComposableVolumeRenderStyleNode):
    def __init__(self, **kwargs):
        super(EdgeEnhancementVolumeStyle, self).__init__(**kwargs)
        edgeColor  = kwargs.pop("edgeColor", [0, 0, 0, 1])
        if edgeColor == None or edgeColor  <  0:
            return None
        if edgeColor == None or edgeColor  >  1:
            return None
        self.__edgeColor = edgeColor
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        gradientThreshold  = kwargs.pop("gradientThreshold", 0.4)
        if gradientThreshold == None or gradientThreshold  <  0:
            return None
        if gradientThreshold == None or gradientThreshold  >  3.1416:
            return None
        self.__gradientThreshold = gradientThreshold
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        surfaceNormals  = kwargs.pop("surfaceNormals", None)
        self.__surfaceNormals = surfaceNormals
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def edgeColor(self):
        return self.__edgeColor
    @edgeColor.setter
    def edgeColor(self, value = [0, 0, 0, 1]):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__edgeColor = [value]
    def setEdgeColor(self, edgeColor = [0, 0, 0, 1]):
        if edgeColor == None or edgeColor  <  0:
            return None
        if edgeColor == None or edgeColor  >  1:
            return None
        self.__edgeColor = [edgeColor]
        return self
    def addEdgeColor(self, edgeColor = [0, 0, 0, 1]):
        if edgeColor == None or edgeColor  <  0:
            return None
        if edgeColor == None or edgeColor  >  1:
            return None
        if self.__edgeColor == None:            self.__edgeColor =  []
        self.__edgeColor +=  [edgeColor]
        return self
    def removeEdgeColor(self, edgeColor):
        self.__edgeColor = [x for x in self.__edgeColor if x not in edgeColor]
        return self.__edgeColor
    def getEdgeColor(self, edgeColor = [0, 0, 0, 1]):
        return self.__edgeColor
    def edgeColor_changed(self, edgeColor = [0, 0, 0, 1]):
        return self.__edgeColor
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def gradientThreshold(self):
        return self.__gradientThreshold
    @gradientThreshold.setter
    def gradientThreshold(self, value = 0.4):
        if value == None or value  <  0:
            return None
        if value == None or value  >  3.1416:
            return None
        self.__gradientThreshold = [value]
    def setGradientThreshold(self, gradientThreshold = 0.4):
        if gradientThreshold == None or gradientThreshold  <  0:
            return None
        if gradientThreshold == None or gradientThreshold  >  3.1416:
            return None
        self.__gradientThreshold = [gradientThreshold]
        return self
    def addGradientThreshold(self, gradientThreshold = 0.4):
        if gradientThreshold == None or gradientThreshold  <  0:
            return None
        if gradientThreshold == None or gradientThreshold  >  3.1416:
            return None
        if self.__gradientThreshold == None:            self.__gradientThreshold =  []
        self.__gradientThreshold +=  [gradientThreshold]
        return self
    def removeGradientThreshold(self, gradientThreshold):
        self.__gradientThreshold = [x for x in self.__gradientThreshold if x not in gradientThreshold]
        return self.__gradientThreshold
    def getGradientThreshold(self, gradientThreshold = 0.4):
        return self.__gradientThreshold
    def gradientThreshold_changed(self, gradientThreshold = 0.4):
        return self.__gradientThreshold
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def surfaceNormals(self):
        return self.__surfaceNormals
    @surfaceNormals.setter
    def surfaceNormals(self, value = None):
        self.__surfaceNormals = [value]
    def setSurfaceNormals(self, surfaceNormals = None):
        self.__surfaceNormals = [surfaceNormals]
        return self
    def addSurfaceNormals(self, surfaceNormals = None):
        if self.__surfaceNormals == None:            self.__surfaceNormals =  []
        self.__surfaceNormals +=  [surfaceNormals]
        return self
    def removeSurfaceNormals(self, surfaceNormals):
        self.__surfaceNormals = [x for x in self.__surfaceNormals if x not in surfaceNormals]
        return self.__surfaceNormals
    def getSurfaceNormals(self, surfaceNormals = None):
        return self.__surfaceNormals
    def surfaceNormals_changed(self, surfaceNormals = None):
        return self.__surfaceNormals
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<EdgeEnhancementVolumeStyle'
        if self.__edgeColor is not None:
            if isinstance(self.__edgeColor, six.string_types):
                str += ' edgeColor="'+self.__edgeColor+'"'
            else:
                str += ' edgeColor="'+self.__edgeColor[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__gradientThreshold is not None:
            if isinstance(self.__gradientThreshold, six.string_types):
                str += ' gradientThreshold="'+self.__gradientThreshold+'"'
            else:
                str += ' gradientThreshold="'+self.__gradientThreshold[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<surfaceNormals'
        if self.__surfaceNormals is not None:
           for s in self.__surfaceNormals:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__surfaceNormals is not None:
           for s in self.__surfaceNormals:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</surfaceNormals>'
        str += '</EdgeEnhancementVolumeStyle>'
        return str


class ElevationGrid(X3DGeometryNode):
    def __init__(self, **kwargs):
        super(ElevationGrid, self).__init__(**kwargs)
        attrib  = kwargs.pop("attrib", None)
        self.__attrib = attrib
        ccw  = kwargs.pop("ccw", True)
        self.__ccw = ccw
        color  = kwargs.pop("color", None)
        self.__color = color
        colorPerVertex  = kwargs.pop("colorPerVertex", True)
        self.__colorPerVertex = colorPerVertex
        creaseAngle  = kwargs.pop("creaseAngle", 0)
        if creaseAngle == None or creaseAngle  <  0:
            return None
        self.__creaseAngle = creaseAngle
        fogCoord  = kwargs.pop("fogCoord", None)
        self.__fogCoord = fogCoord
        height  = kwargs.pop("height", [0, 0, 0, 0])
        self.__height = height
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        normal  = kwargs.pop("normal", None)
        self.__normal = normal
        normalPerVertex  = kwargs.pop("normalPerVertex", True)
        self.__normalPerVertex = normalPerVertex
        height  = kwargs.pop("height", None)
        self.__height = height
        solid  = kwargs.pop("solid", True)
        self.__solid = solid
        texCoord  = kwargs.pop("texCoord", None)
        self.__texCoord = texCoord
        xDimension  = kwargs.pop("xDimension", 2)
        if xDimension == None or xDimension  <  0:
            return None
        self.__xDimension = xDimension
        xSpacing  = kwargs.pop("xSpacing", 1.0)
        if xSpacing == None or xSpacing  <=  0:
            return None
        self.__xSpacing = xSpacing
        zDimension  = kwargs.pop("zDimension", 2)
        if zDimension == None or zDimension  <  0:
            return None
        self.__zDimension = zDimension
        zSpacing  = kwargs.pop("zSpacing", 1.0)
        if zSpacing == None or zSpacing  <=  0:
            return None
        self.__zSpacing = zSpacing
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def attrib(self):
        return self.__attrib
    @attrib.setter
    def attrib(self, value = None):
        self.__attrib = [value]
    def setAttrib(self, attrib = None):
        self.__attrib = [attrib]
        return self
    def addAttrib(self, attrib = None):
        if self.__attrib == None:            self.__attrib =  []
        self.__attrib +=  [attrib]
        return self
    def removeAttrib(self, attrib):
        self.__attrib = [x for x in self.__attrib if x not in attrib]
        return self.__attrib
    def getAttrib(self, attrib = None):
        return self.__attrib
    def attrib_changed(self, attrib = None):
        return self.__attrib
    @property
    def color(self):
        return self.__color
    @color.setter
    def color(self, value = None):
        self.__color = [value]
    def setColor(self, color = None):
        self.__color = [color]
        return self
    def addColor(self, color = None):
        if self.__color == None:            self.__color =  []
        self.__color +=  [color]
        return self
    def removeColor(self, color):
        self.__color = [x for x in self.__color if x not in color]
        return self.__color
    def getColor(self, color = None):
        return self.__color
    def color_changed(self, color = None):
        return self.__color
    @property
    def fogCoord(self):
        return self.__fogCoord
    @fogCoord.setter
    def fogCoord(self, value = None):
        self.__fogCoord = [value]
    def setFogCoord(self, fogCoord = None):
        self.__fogCoord = [fogCoord]
        return self
    def addFogCoord(self, fogCoord = None):
        if self.__fogCoord == None:            self.__fogCoord =  []
        self.__fogCoord +=  [fogCoord]
        return self
    def removeFogCoord(self, fogCoord):
        self.__fogCoord = [x for x in self.__fogCoord if x not in fogCoord]
        return self.__fogCoord
    def getFogCoord(self, fogCoord = None):
        return self.__fogCoord
    def fogCoord_changed(self, fogCoord = None):
        return self.__fogCoord
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def normal(self):
        return self.__normal
    @normal.setter
    def normal(self, value = None):
        self.__normal = [value]
    def setNormal(self, normal = None):
        self.__normal = [normal]
        return self
    def addNormal(self, normal = None):
        if self.__normal == None:            self.__normal =  []
        self.__normal +=  [normal]
        return self
    def removeNormal(self, normal):
        self.__normal = [x for x in self.__normal if x not in normal]
        return self.__normal
    def getNormal(self, normal = None):
        return self.__normal
    def normal_changed(self, normal = None):
        return self.__normal
    @property
    def height(self):
        return self.__height
    @height.setter
    def height(self, value = None):
        self.__height = [value]
    def set_height(self, height = None):
        self.__height = [height]
        return self
    @property
    def texCoord(self):
        return self.__texCoord
    @texCoord.setter
    def texCoord(self, value = None):
        self.__texCoord = [value]
    def setTexCoord(self, texCoord = None):
        self.__texCoord = [texCoord]
        return self
    def addTexCoord(self, texCoord = None):
        if self.__texCoord == None:            self.__texCoord =  []
        self.__texCoord +=  [texCoord]
        return self
    def removeTexCoord(self, texCoord):
        self.__texCoord = [x for x in self.__texCoord if x not in texCoord]
        return self.__texCoord
    def getTexCoord(self, texCoord = None):
        return self.__texCoord
    def texCoord_changed(self, texCoord = None):
        return self.__texCoord
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ElevationGrid'
        if self.__ccw is not None:
            if isinstance(self.__ccw, six.string_types):
                str += ' ccw="'+self.__ccw+'"'
            else:
                str += ' ccw="'+self.__ccw[0]+'"'
        if self.__colorPerVertex is not None:
            if isinstance(self.__colorPerVertex, six.string_types):
                str += ' colorPerVertex="'+self.__colorPerVertex+'"'
            else:
                str += ' colorPerVertex="'+self.__colorPerVertex[0]+'"'
        if self.__creaseAngle is not None:
            if isinstance(self.__creaseAngle, six.string_types):
                str += ' creaseAngle="'+self.__creaseAngle+'"'
            else:
                str += ' creaseAngle="'+self.__creaseAngle[0]+'"'
        if self.__height is not None:
            if isinstance(self.__height, six.string_types):
                str += ' height="'+self.__height+'"'
            else:
                str += ' height="'+self.__height[0]+'"'
        if self.__normalPerVertex is not None:
            if isinstance(self.__normalPerVertex, six.string_types):
                str += ' normalPerVertex="'+self.__normalPerVertex+'"'
            else:
                str += ' normalPerVertex="'+self.__normalPerVertex[0]+'"'
        if self.__height is not None:
            if isinstance(self.__height, six.string_types):
                str += ' height="'+self.__height+'"'
            else:
                str += ' height="'+self.__height[0]+'"'
        if self.__solid is not None:
            if isinstance(self.__solid, six.string_types):
                str += ' solid="'+self.__solid+'"'
            else:
                str += ' solid="'+self.__solid[0]+'"'
        if self.__xDimension is not None:
            if isinstance(self.__xDimension, six.string_types):
                str += ' xDimension="'+self.__xDimension+'"'
            else:
                str += ' xDimension="'+self.__xDimension[0]+'"'
        if self.__xSpacing is not None:
            if isinstance(self.__xSpacing, six.string_types):
                str += ' xSpacing="'+self.__xSpacing+'"'
            else:
                str += ' xSpacing="'+self.__xSpacing[0]+'"'
        if self.__zDimension is not None:
            if isinstance(self.__zDimension, six.string_types):
                str += ' zDimension="'+self.__zDimension+'"'
            else:
                str += ' zDimension="'+self.__zDimension[0]+'"'
        if self.__zSpacing is not None:
            if isinstance(self.__zSpacing, six.string_types):
                str += ' zSpacing="'+self.__zSpacing+'"'
            else:
                str += ' zSpacing="'+self.__zSpacing[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<attrib'
        if self.__attrib is not None:
           for s in self.__attrib:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__attrib is not None:
           for s in self.__attrib:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</attrib>'
        str += '<color'
        if self.__color is not None:
           for s in self.__color:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__color is not None:
           for s in self.__color:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</color>'
        str += '<fogCoord'
        if self.__fogCoord is not None:
           for s in self.__fogCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__fogCoord is not None:
           for s in self.__fogCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</fogCoord>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<normal'
        if self.__normal is not None:
           for s in self.__normal:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__normal is not None:
           for s in self.__normal:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</normal>'
        str += '<texCoord'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</texCoord>'
        str += '</ElevationGrid>'
        return str


class EspduTransform(X3DNetworkSensorNode, X3DGroupingNode):
    def __init__(self, **kwargs):
        super(EspduTransform, self).__init__(**kwargs)
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        address  = kwargs.pop("address", "localhost")
        self.__address = address
        applicationID  = kwargs.pop("applicationID", 0)
        self.__applicationID = applicationID
        articulationParameterArray  = kwargs.pop("articulationParameterArray", None)
        self.__articulationParameterArray = articulationParameterArray
        articulationParameterChangeIndicatorArray  = kwargs.pop("articulationParameterChangeIndicatorArray", None)
        self.__articulationParameterChangeIndicatorArray = articulationParameterChangeIndicatorArray
        articulationParameterCount  = kwargs.pop("articulationParameterCount", 0)
        self.__articulationParameterCount = articulationParameterCount
        articulationParameterDesignatorArray  = kwargs.pop("articulationParameterDesignatorArray", None)
        self.__articulationParameterDesignatorArray = articulationParameterDesignatorArray
        articulationParameterIdPartAttachedToArray  = kwargs.pop("articulationParameterIdPartAttachedToArray", None)
        self.__articulationParameterIdPartAttachedToArray = articulationParameterIdPartAttachedToArray
        articulationParameterTypeArray  = kwargs.pop("articulationParameterTypeArray", None)
        self.__articulationParameterTypeArray = articulationParameterTypeArray
        articulationParameterValue0_changed  = kwargs.pop("articulationParameterValue0_changed", None)
        self.__articulationParameterValue0_changed = articulationParameterValue0_changed
        articulationParameterValue1_changed  = kwargs.pop("articulationParameterValue1_changed", None)
        self.__articulationParameterValue1_changed = articulationParameterValue1_changed
        articulationParameterValue2_changed  = kwargs.pop("articulationParameterValue2_changed", None)
        self.__articulationParameterValue2_changed = articulationParameterValue2_changed
        articulationParameterValue3_changed  = kwargs.pop("articulationParameterValue3_changed", None)
        self.__articulationParameterValue3_changed = articulationParameterValue3_changed
        articulationParameterValue4_changed  = kwargs.pop("articulationParameterValue4_changed", None)
        self.__articulationParameterValue4_changed = articulationParameterValue4_changed
        articulationParameterValue5_changed  = kwargs.pop("articulationParameterValue5_changed", None)
        self.__articulationParameterValue5_changed = articulationParameterValue5_changed
        articulationParameterValue6_changed  = kwargs.pop("articulationParameterValue6_changed", None)
        self.__articulationParameterValue6_changed = articulationParameterValue6_changed
        articulationParameterValue7_changed  = kwargs.pop("articulationParameterValue7_changed", None)
        self.__articulationParameterValue7_changed = articulationParameterValue7_changed
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        center  = kwargs.pop("center", [0, 0, 0])
        self.__center = center
        children  = kwargs.pop("children", None)
        self.__children = children
        collideTime  = kwargs.pop("collideTime", None)
        self.__collideTime = collideTime
        collisionType  = kwargs.pop("collisionType", 0)
        self.__collisionType = collisionType
        deadReckoning  = kwargs.pop("deadReckoning", 0)
        self.__deadReckoning = deadReckoning
        detonateTime  = kwargs.pop("detonateTime", None)
        self.__detonateTime = detonateTime
        detonationLocation  = kwargs.pop("detonationLocation", [0, 0, 0])
        self.__detonationLocation = detonationLocation
        detonationRelativeLocation  = kwargs.pop("detonationRelativeLocation", [0, 0, 0])
        self.__detonationRelativeLocation = detonationRelativeLocation
        detonationResult  = kwargs.pop("detonationResult", 0)
        self.__detonationResult = detonationResult
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        entityCategory  = kwargs.pop("entityCategory", 0)
        self.__entityCategory = entityCategory
        entityCountry  = kwargs.pop("entityCountry", 0)
        self.__entityCountry = entityCountry
        entityDomain  = kwargs.pop("entityDomain", 0)
        self.__entityDomain = entityDomain
        entityExtra  = kwargs.pop("entityExtra", 0)
        self.__entityExtra = entityExtra
        entityID  = kwargs.pop("entityID", 0)
        self.__entityID = entityID
        entityKind  = kwargs.pop("entityKind", 0)
        self.__entityKind = entityKind
        entitySpecific  = kwargs.pop("entitySpecific", 0)
        self.__entitySpecific = entitySpecific
        entitySubcategory  = kwargs.pop("entitySubcategory", 0)
        self.__entitySubcategory = entitySubcategory
        eventApplicationID  = kwargs.pop("eventApplicationID", 0)
        self.__eventApplicationID = eventApplicationID
        eventEntityID  = kwargs.pop("eventEntityID", 0)
        self.__eventEntityID = eventEntityID
        eventNumber  = kwargs.pop("eventNumber", 0)
        self.__eventNumber = eventNumber
        eventSiteID  = kwargs.pop("eventSiteID", 0)
        self.__eventSiteID = eventSiteID
        fired1  = kwargs.pop("fired1", False)
        self.__fired1 = fired1
        fired2  = kwargs.pop("fired2", False)
        self.__fired2 = fired2
        firedTime  = kwargs.pop("firedTime", None)
        self.__firedTime = firedTime
        fireMissionIndex  = kwargs.pop("fireMissionIndex", 0)
        self.__fireMissionIndex = fireMissionIndex
        firingRange  = kwargs.pop("firingRange", 0)
        self.__firingRange = firingRange
        firingRate  = kwargs.pop("firingRate", 0)
        self.__firingRate = firingRate
        forceID  = kwargs.pop("forceID", 0)
        self.__forceID = forceID
        fuse  = kwargs.pop("fuse", 0)
        self.__fuse = fuse
        geoCoords  = kwargs.pop("geoCoords", [0, 0, 0])
        self.__geoCoords = geoCoords
        geoSystem  = kwargs.pop("geoSystem", ["GD", "WE"])
        self.__geoSystem = geoSystem
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        Collided  = kwargs.pop("Collided", None)
        self.__Collided = Collided
        Detonated  = kwargs.pop("Detonated", None)
        self.__Detonated = Detonated
        NetworkReader  = kwargs.pop("NetworkReader", None)
        self.__NetworkReader = NetworkReader
        NetworkWriter  = kwargs.pop("NetworkWriter", None)
        self.__NetworkWriter = NetworkWriter
        RtpHeaderHeard  = kwargs.pop("RtpHeaderHeard", None)
        self.__RtpHeaderHeard = RtpHeaderHeard
        StandAlone  = kwargs.pop("StandAlone", None)
        self.__StandAlone = StandAlone
        linearAcceleration  = kwargs.pop("linearAcceleration", [0, 0, 0])
        self.__linearAcceleration = linearAcceleration
        linearVelocity  = kwargs.pop("linearVelocity", [0, 0, 0])
        self.__linearVelocity = linearVelocity
        marking  = kwargs.pop("marking", None)
        self.__marking = marking
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        multicastRelayHost  = kwargs.pop("multicastRelayHost", None)
        self.__multicastRelayHost = multicastRelayHost
        multicastRelayPort  = kwargs.pop("multicastRelayPort", 0)
        self.__multicastRelayPort = multicastRelayPort
        munitionApplicationID  = kwargs.pop("munitionApplicationID", 0)
        self.__munitionApplicationID = munitionApplicationID
        munitionEndPoint  = kwargs.pop("munitionEndPoint", [0, 0, 0])
        self.__munitionEndPoint = munitionEndPoint
        munitionEntityID  = kwargs.pop("munitionEntityID", 0)
        self.__munitionEntityID = munitionEntityID
        munitionQuantity  = kwargs.pop("munitionQuantity", 0)
        self.__munitionQuantity = munitionQuantity
        munitionSiteID  = kwargs.pop("munitionSiteID", 0)
        self.__munitionSiteID = munitionSiteID
        munitionStartPoint  = kwargs.pop("munitionStartPoint", [0, 0, 0])
        self.__munitionStartPoint = munitionStartPoint
        networkMode  = kwargs.pop("networkMode", "standAlone")
        if 'standAlone' == networkMode:
            pass
        elif 'networkReader' == networkMode:
            pass
        elif 'networkWriter' == networkMode:
            pass
        else:
            return None
        self.__networkMode = networkMode
        port  = kwargs.pop("port", 0)
        self.__port = port
        readInterval  = kwargs.pop("readInterval", 0.1)
        if readInterval == None or readInterval  <  0:
            return None
        self.__readInterval = readInterval
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        rotation  = kwargs.pop("rotation", [0, 0, 1, 0])
        self.__rotation = rotation
        rtpHeaderExpected  = kwargs.pop("rtpHeaderExpected", False)
        self.__rtpHeaderExpected = rtpHeaderExpected
        scale  = kwargs.pop("scale", [1, 1, 1])
        self.__scale = scale
        scaleOrientation  = kwargs.pop("scaleOrientation", [0, 0, 1, 0])
        self.__scaleOrientation = scaleOrientation
        articulationParameterValue0  = kwargs.pop("articulationParameterValue0", None)
        self.__articulationParameterValue0 = articulationParameterValue0
        articulationParameterValue1  = kwargs.pop("articulationParameterValue1", None)
        self.__articulationParameterValue1 = articulationParameterValue1
        articulationParameterValue2  = kwargs.pop("articulationParameterValue2", None)
        self.__articulationParameterValue2 = articulationParameterValue2
        articulationParameterValue3  = kwargs.pop("articulationParameterValue3", None)
        self.__articulationParameterValue3 = articulationParameterValue3
        articulationParameterValue4  = kwargs.pop("articulationParameterValue4", None)
        self.__articulationParameterValue4 = articulationParameterValue4
        articulationParameterValue5  = kwargs.pop("articulationParameterValue5", None)
        self.__articulationParameterValue5 = articulationParameterValue5
        articulationParameterValue6  = kwargs.pop("articulationParameterValue6", None)
        self.__articulationParameterValue6 = articulationParameterValue6
        articulationParameterValue7  = kwargs.pop("articulationParameterValue7", None)
        self.__articulationParameterValue7 = articulationParameterValue7
        siteID  = kwargs.pop("siteID", 0)
        self.__siteID = siteID
        timestamp  = kwargs.pop("timestamp", None)
        if timestamp == None or timestamp  <  0:
            return None
        self.__timestamp = timestamp
        translation  = kwargs.pop("translation", [0, 0, 0])
        self.__translation = translation
        warhead  = kwargs.pop("warhead", 0)
        self.__warhead = warhead
        writeInterval  = kwargs.pop("writeInterval", 1.0)
        if writeInterval == None or writeInterval  <  0:
            return None
        self.__writeInterval = writeInterval
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    def addChildren(self, Children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [Children]
        return self
    @property
    def address(self):
        return self.__address
    @address.setter
    def address(self, value = "localhost"):
        self.__address = [value]
    def address(self, address = "localhost"):
        if self.__address == None:            self.__address =  []
        self.__address +=  [address]
        return self
    def removeAddress(self, address):
        self.__address = [x for x in self.__address if x not in address]
        return self.__address
    def getAddress(self, address = "localhost"):
        return self.__address
    def address_changed(self, address = "localhost"):
        return self.__address
    @property
    def applicationID(self):
        return self.__applicationID
    @applicationID.setter
    def applicationID(self, value = 0):
        self.__applicationID = [value]
    def setApplicationID(self, applicationID = 0):
        self.__applicationID = [applicationID]
        return self
    def addApplicationID(self, applicationID = 0):
        if self.__applicationID == None:            self.__applicationID =  []
        self.__applicationID +=  [applicationID]
        return self
    def removeApplicationID(self, applicationID):
        self.__applicationID = [x for x in self.__applicationID if x not in applicationID]
        return self.__applicationID
    def getApplicationID(self, applicationID = 0):
        return self.__applicationID
    def applicationID_changed(self, applicationID = 0):
        return self.__applicationID
    @property
    def articulationParameterArray(self):
        return self.__articulationParameterArray
    @articulationParameterArray.setter
    def articulationParameterArray(self, value = None):
        self.__articulationParameterArray = [value]
    def setArticulationParameterArray(self, articulationParameterArray = None):
        self.__articulationParameterArray = [articulationParameterArray]
        return self
    def addArticulationParameterArray(self, articulationParameterArray = None):
        if self.__articulationParameterArray == None:            self.__articulationParameterArray =  []
        self.__articulationParameterArray +=  [articulationParameterArray]
        return self
    def removeArticulationParameterArray(self, articulationParameterArray):
        self.__articulationParameterArray = [x for x in self.__articulationParameterArray if x not in articulationParameterArray]
        return self.__articulationParameterArray
    def getArticulationParameterArray(self, articulationParameterArray = None):
        return self.__articulationParameterArray
    def articulationParameterArray_changed(self, articulationParameterArray = None):
        return self.__articulationParameterArray
    @property
    def articulationParameterChangeIndicatorArray(self):
        return self.__articulationParameterChangeIndicatorArray
    @articulationParameterChangeIndicatorArray.setter
    def articulationParameterChangeIndicatorArray(self, value = None):
        self.__articulationParameterChangeIndicatorArray = [value]
    def setArticulationParameterChangeIndicatorArray(self, articulationParameterChangeIndicatorArray = None):
        self.__articulationParameterChangeIndicatorArray = [articulationParameterChangeIndicatorArray]
        return self
    def addArticulationParameterChangeIndicatorArray(self, articulationParameterChangeIndicatorArray = None):
        if self.__articulationParameterChangeIndicatorArray == None:            self.__articulationParameterChangeIndicatorArray =  []
        self.__articulationParameterChangeIndicatorArray +=  [articulationParameterChangeIndicatorArray]
        return self
    def removeArticulationParameterChangeIndicatorArray(self, articulationParameterChangeIndicatorArray):
        self.__articulationParameterChangeIndicatorArray = [x for x in self.__articulationParameterChangeIndicatorArray if x not in articulationParameterChangeIndicatorArray]
        return self.__articulationParameterChangeIndicatorArray
    def getArticulationParameterChangeIndicatorArray(self, articulationParameterChangeIndicatorArray = None):
        return self.__articulationParameterChangeIndicatorArray
    def articulationParameterChangeIndicatorArray_changed(self, articulationParameterChangeIndicatorArray = None):
        return self.__articulationParameterChangeIndicatorArray
    @property
    def articulationParameterCount(self):
        return self.__articulationParameterCount
    @articulationParameterCount.setter
    def articulationParameterCount(self, value = 0):
        self.__articulationParameterCount = [value]
    def setArticulationParameterCount(self, articulationParameterCount = 0):
        self.__articulationParameterCount = [articulationParameterCount]
        return self
    def addArticulationParameterCount(self, articulationParameterCount = 0):
        if self.__articulationParameterCount == None:            self.__articulationParameterCount =  []
        self.__articulationParameterCount +=  [articulationParameterCount]
        return self
    def removeArticulationParameterCount(self, articulationParameterCount):
        self.__articulationParameterCount = [x for x in self.__articulationParameterCount if x not in articulationParameterCount]
        return self.__articulationParameterCount
    def getArticulationParameterCount(self, articulationParameterCount = 0):
        return self.__articulationParameterCount
    def articulationParameterCount_changed(self, articulationParameterCount = 0):
        return self.__articulationParameterCount
    @property
    def articulationParameterDesignatorArray(self):
        return self.__articulationParameterDesignatorArray
    @articulationParameterDesignatorArray.setter
    def articulationParameterDesignatorArray(self, value = None):
        self.__articulationParameterDesignatorArray = [value]
    def setArticulationParameterDesignatorArray(self, articulationParameterDesignatorArray = None):
        self.__articulationParameterDesignatorArray = [articulationParameterDesignatorArray]
        return self
    def addArticulationParameterDesignatorArray(self, articulationParameterDesignatorArray = None):
        if self.__articulationParameterDesignatorArray == None:            self.__articulationParameterDesignatorArray =  []
        self.__articulationParameterDesignatorArray +=  [articulationParameterDesignatorArray]
        return self
    def removeArticulationParameterDesignatorArray(self, articulationParameterDesignatorArray):
        self.__articulationParameterDesignatorArray = [x for x in self.__articulationParameterDesignatorArray if x not in articulationParameterDesignatorArray]
        return self.__articulationParameterDesignatorArray
    def getArticulationParameterDesignatorArray(self, articulationParameterDesignatorArray = None):
        return self.__articulationParameterDesignatorArray
    def articulationParameterDesignatorArray_changed(self, articulationParameterDesignatorArray = None):
        return self.__articulationParameterDesignatorArray
    @property
    def articulationParameterIdPartAttachedToArray(self):
        return self.__articulationParameterIdPartAttachedToArray
    @articulationParameterIdPartAttachedToArray.setter
    def articulationParameterIdPartAttachedToArray(self, value = None):
        self.__articulationParameterIdPartAttachedToArray = [value]
    def setArticulationParameterIdPartAttachedToArray(self, articulationParameterIdPartAttachedToArray = None):
        self.__articulationParameterIdPartAttachedToArray = [articulationParameterIdPartAttachedToArray]
        return self
    def addArticulationParameterIdPartAttachedToArray(self, articulationParameterIdPartAttachedToArray = None):
        if self.__articulationParameterIdPartAttachedToArray == None:            self.__articulationParameterIdPartAttachedToArray =  []
        self.__articulationParameterIdPartAttachedToArray +=  [articulationParameterIdPartAttachedToArray]
        return self
    def removeArticulationParameterIdPartAttachedToArray(self, articulationParameterIdPartAttachedToArray):
        self.__articulationParameterIdPartAttachedToArray = [x for x in self.__articulationParameterIdPartAttachedToArray if x not in articulationParameterIdPartAttachedToArray]
        return self.__articulationParameterIdPartAttachedToArray
    def getArticulationParameterIdPartAttachedToArray(self, articulationParameterIdPartAttachedToArray = None):
        return self.__articulationParameterIdPartAttachedToArray
    def articulationParameterIdPartAttachedToArray_changed(self, articulationParameterIdPartAttachedToArray = None):
        return self.__articulationParameterIdPartAttachedToArray
    @property
    def articulationParameterTypeArray(self):
        return self.__articulationParameterTypeArray
    @articulationParameterTypeArray.setter
    def articulationParameterTypeArray(self, value = None):
        self.__articulationParameterTypeArray = [value]
    def setArticulationParameterTypeArray(self, articulationParameterTypeArray = None):
        self.__articulationParameterTypeArray = [articulationParameterTypeArray]
        return self
    def addArticulationParameterTypeArray(self, articulationParameterTypeArray = None):
        if self.__articulationParameterTypeArray == None:            self.__articulationParameterTypeArray =  []
        self.__articulationParameterTypeArray +=  [articulationParameterTypeArray]
        return self
    def removeArticulationParameterTypeArray(self, articulationParameterTypeArray):
        self.__articulationParameterTypeArray = [x for x in self.__articulationParameterTypeArray if x not in articulationParameterTypeArray]
        return self.__articulationParameterTypeArray
    def getArticulationParameterTypeArray(self, articulationParameterTypeArray = None):
        return self.__articulationParameterTypeArray
    def articulationParameterTypeArray_changed(self, articulationParameterTypeArray = None):
        return self.__articulationParameterTypeArray
    def removearticulationParameterValue0_changed(self, articulationParameterValue0_changed):
        self.__articulationParameterValue0_changed = [x for x in self.__articulationParameterValue0_changed if x not in articulationParameterValue0_changed]
        return self.__articulationParameterValue0_changed
    def getarticulationParameterValue0_changed(self, articulationParameterValue0_changed = None):
        return self.__articulationParameterValue0_changed
    def articulationParameterValue0_changed_changed(self, articulationParameterValue0_changed = None):
        return self.__articulationParameterValue0_changed
    def removearticulationParameterValue1_changed(self, articulationParameterValue1_changed):
        self.__articulationParameterValue1_changed = [x for x in self.__articulationParameterValue1_changed if x not in articulationParameterValue1_changed]
        return self.__articulationParameterValue1_changed
    def getarticulationParameterValue1_changed(self, articulationParameterValue1_changed = None):
        return self.__articulationParameterValue1_changed
    def articulationParameterValue1_changed_changed(self, articulationParameterValue1_changed = None):
        return self.__articulationParameterValue1_changed
    def removearticulationParameterValue2_changed(self, articulationParameterValue2_changed):
        self.__articulationParameterValue2_changed = [x for x in self.__articulationParameterValue2_changed if x not in articulationParameterValue2_changed]
        return self.__articulationParameterValue2_changed
    def getarticulationParameterValue2_changed(self, articulationParameterValue2_changed = None):
        return self.__articulationParameterValue2_changed
    def articulationParameterValue2_changed_changed(self, articulationParameterValue2_changed = None):
        return self.__articulationParameterValue2_changed
    def removearticulationParameterValue3_changed(self, articulationParameterValue3_changed):
        self.__articulationParameterValue3_changed = [x for x in self.__articulationParameterValue3_changed if x not in articulationParameterValue3_changed]
        return self.__articulationParameterValue3_changed
    def getarticulationParameterValue3_changed(self, articulationParameterValue3_changed = None):
        return self.__articulationParameterValue3_changed
    def articulationParameterValue3_changed_changed(self, articulationParameterValue3_changed = None):
        return self.__articulationParameterValue3_changed
    def removearticulationParameterValue4_changed(self, articulationParameterValue4_changed):
        self.__articulationParameterValue4_changed = [x for x in self.__articulationParameterValue4_changed if x not in articulationParameterValue4_changed]
        return self.__articulationParameterValue4_changed
    def getarticulationParameterValue4_changed(self, articulationParameterValue4_changed = None):
        return self.__articulationParameterValue4_changed
    def articulationParameterValue4_changed_changed(self, articulationParameterValue4_changed = None):
        return self.__articulationParameterValue4_changed
    def removearticulationParameterValue5_changed(self, articulationParameterValue5_changed):
        self.__articulationParameterValue5_changed = [x for x in self.__articulationParameterValue5_changed if x not in articulationParameterValue5_changed]
        return self.__articulationParameterValue5_changed
    def getarticulationParameterValue5_changed(self, articulationParameterValue5_changed = None):
        return self.__articulationParameterValue5_changed
    def articulationParameterValue5_changed_changed(self, articulationParameterValue5_changed = None):
        return self.__articulationParameterValue5_changed
    def removearticulationParameterValue6_changed(self, articulationParameterValue6_changed):
        self.__articulationParameterValue6_changed = [x for x in self.__articulationParameterValue6_changed if x not in articulationParameterValue6_changed]
        return self.__articulationParameterValue6_changed
    def getarticulationParameterValue6_changed(self, articulationParameterValue6_changed = None):
        return self.__articulationParameterValue6_changed
    def articulationParameterValue6_changed_changed(self, articulationParameterValue6_changed = None):
        return self.__articulationParameterValue6_changed
    def removearticulationParameterValue7_changed(self, articulationParameterValue7_changed):
        self.__articulationParameterValue7_changed = [x for x in self.__articulationParameterValue7_changed if x not in articulationParameterValue7_changed]
        return self.__articulationParameterValue7_changed
    def getarticulationParameterValue7_changed(self, articulationParameterValue7_changed = None):
        return self.__articulationParameterValue7_changed
    def articulationParameterValue7_changed_changed(self, articulationParameterValue7_changed = None):
        return self.__articulationParameterValue7_changed
    @property
    def center(self):
        return self.__center
    @center.setter
    def center(self, value = [0, 0, 0]):
        self.__center = [value]
    def setCenter(self, center = [0, 0, 0]):
        self.__center = [center]
        return self
    def addCenter(self, center = [0, 0, 0]):
        if self.__center == None:            self.__center =  []
        self.__center +=  [center]
        return self
    def removeCenter(self, center):
        self.__center = [x for x in self.__center if x not in center]
        return self.__center
    def getCenter(self, center = [0, 0, 0]):
        return self.__center
    def center_changed(self, center = [0, 0, 0]):
        return self.__center
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    def removeCollideTime(self, collideTime):
        self.__collideTime = [x for x in self.__collideTime if x not in collideTime]
        return self.__collideTime
    def getCollideTime(self, collideTime = None):
        return self.__collideTime
    def collideTime_changed(self, collideTime = None):
        return self.__collideTime
    @property
    def collisionType(self):
        return self.__collisionType
    @collisionType.setter
    def collisionType(self, value = 0):
        self.__collisionType = [value]
    def setCollisionType(self, collisionType = 0):
        self.__collisionType = [collisionType]
        return self
    def addCollisionType(self, collisionType = 0):
        if self.__collisionType == None:            self.__collisionType =  []
        self.__collisionType +=  [collisionType]
        return self
    def removeCollisionType(self, collisionType):
        self.__collisionType = [x for x in self.__collisionType if x not in collisionType]
        return self.__collisionType
    def getCollisionType(self, collisionType = 0):
        return self.__collisionType
    def collisionType_changed(self, collisionType = 0):
        return self.__collisionType
    @property
    def deadReckoning(self):
        return self.__deadReckoning
    @deadReckoning.setter
    def deadReckoning(self, value = 0):
        self.__deadReckoning = [value]
    def setDeadReckoning(self, deadReckoning = 0):
        self.__deadReckoning = [deadReckoning]
        return self
    def addDeadReckoning(self, deadReckoning = 0):
        if self.__deadReckoning == None:            self.__deadReckoning =  []
        self.__deadReckoning +=  [deadReckoning]
        return self
    def removeDeadReckoning(self, deadReckoning):
        self.__deadReckoning = [x for x in self.__deadReckoning if x not in deadReckoning]
        return self.__deadReckoning
    def getDeadReckoning(self, deadReckoning = 0):
        return self.__deadReckoning
    def deadReckoning_changed(self, deadReckoning = 0):
        return self.__deadReckoning
    def removeDetonateTime(self, detonateTime):
        self.__detonateTime = [x for x in self.__detonateTime if x not in detonateTime]
        return self.__detonateTime
    def getDetonateTime(self, detonateTime = None):
        return self.__detonateTime
    def detonateTime_changed(self, detonateTime = None):
        return self.__detonateTime
    @property
    def detonationLocation(self):
        return self.__detonationLocation
    @detonationLocation.setter
    def detonationLocation(self, value = [0, 0, 0]):
        self.__detonationLocation = [value]
    def setDetonationLocation(self, detonationLocation = [0, 0, 0]):
        self.__detonationLocation = [detonationLocation]
        return self
    def addDetonationLocation(self, detonationLocation = [0, 0, 0]):
        if self.__detonationLocation == None:            self.__detonationLocation =  []
        self.__detonationLocation +=  [detonationLocation]
        return self
    def removeDetonationLocation(self, detonationLocation):
        self.__detonationLocation = [x for x in self.__detonationLocation if x not in detonationLocation]
        return self.__detonationLocation
    def getDetonationLocation(self, detonationLocation = [0, 0, 0]):
        return self.__detonationLocation
    def detonationLocation_changed(self, detonationLocation = [0, 0, 0]):
        return self.__detonationLocation
    @property
    def detonationRelativeLocation(self):
        return self.__detonationRelativeLocation
    @detonationRelativeLocation.setter
    def detonationRelativeLocation(self, value = [0, 0, 0]):
        self.__detonationRelativeLocation = [value]
    def setDetonationRelativeLocation(self, detonationRelativeLocation = [0, 0, 0]):
        self.__detonationRelativeLocation = [detonationRelativeLocation]
        return self
    def addDetonationRelativeLocation(self, detonationRelativeLocation = [0, 0, 0]):
        if self.__detonationRelativeLocation == None:            self.__detonationRelativeLocation =  []
        self.__detonationRelativeLocation +=  [detonationRelativeLocation]
        return self
    def removeDetonationRelativeLocation(self, detonationRelativeLocation):
        self.__detonationRelativeLocation = [x for x in self.__detonationRelativeLocation if x not in detonationRelativeLocation]
        return self.__detonationRelativeLocation
    def getDetonationRelativeLocation(self, detonationRelativeLocation = [0, 0, 0]):
        return self.__detonationRelativeLocation
    def detonationRelativeLocation_changed(self, detonationRelativeLocation = [0, 0, 0]):
        return self.__detonationRelativeLocation
    @property
    def detonationResult(self):
        return self.__detonationResult
    @detonationResult.setter
    def detonationResult(self, value = 0):
        self.__detonationResult = [value]
    def setDetonationResult(self, detonationResult = 0):
        self.__detonationResult = [detonationResult]
        return self
    def addDetonationResult(self, detonationResult = 0):
        if self.__detonationResult == None:            self.__detonationResult =  []
        self.__detonationResult +=  [detonationResult]
        return self
    def removeDetonationResult(self, detonationResult):
        self.__detonationResult = [x for x in self.__detonationResult if x not in detonationResult]
        return self.__detonationResult
    def getDetonationResult(self, detonationResult = 0):
        return self.__detonationResult
    def detonationResult_changed(self, detonationResult = 0):
        return self.__detonationResult
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def entityCategory(self):
        return self.__entityCategory
    @entityCategory.setter
    def entityCategory(self, value = 0):
        self.__entityCategory = [value]
    def setEntityCategory(self, entityCategory = 0):
        self.__entityCategory = [entityCategory]
        return self
    def addEntityCategory(self, entityCategory = 0):
        if self.__entityCategory == None:            self.__entityCategory =  []
        self.__entityCategory +=  [entityCategory]
        return self
    def removeEntityCategory(self, entityCategory):
        self.__entityCategory = [x for x in self.__entityCategory if x not in entityCategory]
        return self.__entityCategory
    def getEntityCategory(self, entityCategory = 0):
        return self.__entityCategory
    def entityCategory_changed(self, entityCategory = 0):
        return self.__entityCategory
    @property
    def entityCountry(self):
        return self.__entityCountry
    @entityCountry.setter
    def entityCountry(self, value = 0):
        self.__entityCountry = [value]
    def setEntityCountry(self, entityCountry = 0):
        self.__entityCountry = [entityCountry]
        return self
    def addEntityCountry(self, entityCountry = 0):
        if self.__entityCountry == None:            self.__entityCountry =  []
        self.__entityCountry +=  [entityCountry]
        return self
    def removeEntityCountry(self, entityCountry):
        self.__entityCountry = [x for x in self.__entityCountry if x not in entityCountry]
        return self.__entityCountry
    def getEntityCountry(self, entityCountry = 0):
        return self.__entityCountry
    def entityCountry_changed(self, entityCountry = 0):
        return self.__entityCountry
    @property
    def entityDomain(self):
        return self.__entityDomain
    @entityDomain.setter
    def entityDomain(self, value = 0):
        self.__entityDomain = [value]
    def setEntityDomain(self, entityDomain = 0):
        self.__entityDomain = [entityDomain]
        return self
    def addEntityDomain(self, entityDomain = 0):
        if self.__entityDomain == None:            self.__entityDomain =  []
        self.__entityDomain +=  [entityDomain]
        return self
    def removeEntityDomain(self, entityDomain):
        self.__entityDomain = [x for x in self.__entityDomain if x not in entityDomain]
        return self.__entityDomain
    def getEntityDomain(self, entityDomain = 0):
        return self.__entityDomain
    def entityDomain_changed(self, entityDomain = 0):
        return self.__entityDomain
    @property
    def entityExtra(self):
        return self.__entityExtra
    @entityExtra.setter
    def entityExtra(self, value = 0):
        self.__entityExtra = [value]
    def setEntityExtra(self, entityExtra = 0):
        self.__entityExtra = [entityExtra]
        return self
    def addEntityExtra(self, entityExtra = 0):
        if self.__entityExtra == None:            self.__entityExtra =  []
        self.__entityExtra +=  [entityExtra]
        return self
    def removeEntityExtra(self, entityExtra):
        self.__entityExtra = [x for x in self.__entityExtra if x not in entityExtra]
        return self.__entityExtra
    def getEntityExtra(self, entityExtra = 0):
        return self.__entityExtra
    def entityExtra_changed(self, entityExtra = 0):
        return self.__entityExtra
    @property
    def entityID(self):
        return self.__entityID
    @entityID.setter
    def entityID(self, value = 0):
        self.__entityID = [value]
    def setEntityID(self, entityID = 0):
        self.__entityID = [entityID]
        return self
    def addEntityID(self, entityID = 0):
        if self.__entityID == None:            self.__entityID =  []
        self.__entityID +=  [entityID]
        return self
    def removeEntityID(self, entityID):
        self.__entityID = [x for x in self.__entityID if x not in entityID]
        return self.__entityID
    def getEntityID(self, entityID = 0):
        return self.__entityID
    def entityID_changed(self, entityID = 0):
        return self.__entityID
    @property
    def entityKind(self):
        return self.__entityKind
    @entityKind.setter
    def entityKind(self, value = 0):
        self.__entityKind = [value]
    def setEntityKind(self, entityKind = 0):
        self.__entityKind = [entityKind]
        return self
    def addEntityKind(self, entityKind = 0):
        if self.__entityKind == None:            self.__entityKind =  []
        self.__entityKind +=  [entityKind]
        return self
    def removeEntityKind(self, entityKind):
        self.__entityKind = [x for x in self.__entityKind if x not in entityKind]
        return self.__entityKind
    def getEntityKind(self, entityKind = 0):
        return self.__entityKind
    def entityKind_changed(self, entityKind = 0):
        return self.__entityKind
    @property
    def entitySpecific(self):
        return self.__entitySpecific
    @entitySpecific.setter
    def entitySpecific(self, value = 0):
        self.__entitySpecific = [value]
    def setEntitySpecific(self, entitySpecific = 0):
        self.__entitySpecific = [entitySpecific]
        return self
    def addEntitySpecific(self, entitySpecific = 0):
        if self.__entitySpecific == None:            self.__entitySpecific =  []
        self.__entitySpecific +=  [entitySpecific]
        return self
    def removeEntitySpecific(self, entitySpecific):
        self.__entitySpecific = [x for x in self.__entitySpecific if x not in entitySpecific]
        return self.__entitySpecific
    def getEntitySpecific(self, entitySpecific = 0):
        return self.__entitySpecific
    def entitySpecific_changed(self, entitySpecific = 0):
        return self.__entitySpecific
    @property
    def entitySubcategory(self):
        return self.__entitySubcategory
    @entitySubcategory.setter
    def entitySubcategory(self, value = 0):
        self.__entitySubcategory = [value]
    def setEntitySubcategory(self, entitySubcategory = 0):
        self.__entitySubcategory = [entitySubcategory]
        return self
    def addEntitySubcategory(self, entitySubcategory = 0):
        if self.__entitySubcategory == None:            self.__entitySubcategory =  []
        self.__entitySubcategory +=  [entitySubcategory]
        return self
    def removeEntitySubcategory(self, entitySubcategory):
        self.__entitySubcategory = [x for x in self.__entitySubcategory if x not in entitySubcategory]
        return self.__entitySubcategory
    def getEntitySubcategory(self, entitySubcategory = 0):
        return self.__entitySubcategory
    def entitySubcategory_changed(self, entitySubcategory = 0):
        return self.__entitySubcategory
    @property
    def eventApplicationID(self):
        return self.__eventApplicationID
    @eventApplicationID.setter
    def eventApplicationID(self, value = 0):
        self.__eventApplicationID = [value]
    def setEventApplicationID(self, eventApplicationID = 0):
        self.__eventApplicationID = [eventApplicationID]
        return self
    def addEventApplicationID(self, eventApplicationID = 0):
        if self.__eventApplicationID == None:            self.__eventApplicationID =  []
        self.__eventApplicationID +=  [eventApplicationID]
        return self
    def removeEventApplicationID(self, eventApplicationID):
        self.__eventApplicationID = [x for x in self.__eventApplicationID if x not in eventApplicationID]
        return self.__eventApplicationID
    def getEventApplicationID(self, eventApplicationID = 0):
        return self.__eventApplicationID
    def eventApplicationID_changed(self, eventApplicationID = 0):
        return self.__eventApplicationID
    @property
    def eventEntityID(self):
        return self.__eventEntityID
    @eventEntityID.setter
    def eventEntityID(self, value = 0):
        self.__eventEntityID = [value]
    def setEventEntityID(self, eventEntityID = 0):
        self.__eventEntityID = [eventEntityID]
        return self
    def addEventEntityID(self, eventEntityID = 0):
        if self.__eventEntityID == None:            self.__eventEntityID =  []
        self.__eventEntityID +=  [eventEntityID]
        return self
    def removeEventEntityID(self, eventEntityID):
        self.__eventEntityID = [x for x in self.__eventEntityID if x not in eventEntityID]
        return self.__eventEntityID
    def getEventEntityID(self, eventEntityID = 0):
        return self.__eventEntityID
    def eventEntityID_changed(self, eventEntityID = 0):
        return self.__eventEntityID
    @property
    def eventNumber(self):
        return self.__eventNumber
    @eventNumber.setter
    def eventNumber(self, value = 0):
        self.__eventNumber = [value]
    def setEventNumber(self, eventNumber = 0):
        self.__eventNumber = [eventNumber]
        return self
    def addEventNumber(self, eventNumber = 0):
        if self.__eventNumber == None:            self.__eventNumber =  []
        self.__eventNumber +=  [eventNumber]
        return self
    def removeEventNumber(self, eventNumber):
        self.__eventNumber = [x for x in self.__eventNumber if x not in eventNumber]
        return self.__eventNumber
    def getEventNumber(self, eventNumber = 0):
        return self.__eventNumber
    def eventNumber_changed(self, eventNumber = 0):
        return self.__eventNumber
    @property
    def eventSiteID(self):
        return self.__eventSiteID
    @eventSiteID.setter
    def eventSiteID(self, value = 0):
        self.__eventSiteID = [value]
    def setEventSiteID(self, eventSiteID = 0):
        self.__eventSiteID = [eventSiteID]
        return self
    def addEventSiteID(self, eventSiteID = 0):
        if self.__eventSiteID == None:            self.__eventSiteID =  []
        self.__eventSiteID +=  [eventSiteID]
        return self
    def removeEventSiteID(self, eventSiteID):
        self.__eventSiteID = [x for x in self.__eventSiteID if x not in eventSiteID]
        return self.__eventSiteID
    def getEventSiteID(self, eventSiteID = 0):
        return self.__eventSiteID
    def eventSiteID_changed(self, eventSiteID = 0):
        return self.__eventSiteID
    @property
    def fired1(self):
        return self.__fired1
    @fired1.setter
    def fired1(self, value = False):
        self.__fired1 = [value]
    def setFired1(self, fired1 = False):
        self.__fired1 = [fired1]
        return self
    def addFired1(self, fired1 = False):
        if self.__fired1 == None:            self.__fired1 =  []
        self.__fired1 +=  [fired1]
        return self
    def removeFired1(self, fired1):
        self.__fired1 = [x for x in self.__fired1 if x not in fired1]
        return self.__fired1
    def isFired1(self, fired1 = False):
        return self.__fired1
    @property
    def fired2(self):
        return self.__fired2
    @fired2.setter
    def fired2(self, value = False):
        self.__fired2 = [value]
    def setFired2(self, fired2 = False):
        self.__fired2 = [fired2]
        return self
    def addFired2(self, fired2 = False):
        if self.__fired2 == None:            self.__fired2 =  []
        self.__fired2 +=  [fired2]
        return self
    def removeFired2(self, fired2):
        self.__fired2 = [x for x in self.__fired2 if x not in fired2]
        return self.__fired2
    def isFired2(self, fired2 = False):
        return self.__fired2
    def removeFiredTime(self, firedTime):
        self.__firedTime = [x for x in self.__firedTime if x not in firedTime]
        return self.__firedTime
    def getFiredTime(self, firedTime = None):
        return self.__firedTime
    def firedTime_changed(self, firedTime = None):
        return self.__firedTime
    @property
    def fireMissionIndex(self):
        return self.__fireMissionIndex
    @fireMissionIndex.setter
    def fireMissionIndex(self, value = 0):
        self.__fireMissionIndex = [value]
    def setFireMissionIndex(self, fireMissionIndex = 0):
        self.__fireMissionIndex = [fireMissionIndex]
        return self
    def addFireMissionIndex(self, fireMissionIndex = 0):
        if self.__fireMissionIndex == None:            self.__fireMissionIndex =  []
        self.__fireMissionIndex +=  [fireMissionIndex]
        return self
    def removeFireMissionIndex(self, fireMissionIndex):
        self.__fireMissionIndex = [x for x in self.__fireMissionIndex if x not in fireMissionIndex]
        return self.__fireMissionIndex
    def getFireMissionIndex(self, fireMissionIndex = 0):
        return self.__fireMissionIndex
    def fireMissionIndex_changed(self, fireMissionIndex = 0):
        return self.__fireMissionIndex
    @property
    def firingRange(self):
        return self.__firingRange
    @firingRange.setter
    def firingRange(self, value = 0):
        self.__firingRange = [value]
    def setFiringRange(self, firingRange = 0):
        self.__firingRange = [firingRange]
        return self
    def addFiringRange(self, firingRange = 0):
        if self.__firingRange == None:            self.__firingRange =  []
        self.__firingRange +=  [firingRange]
        return self
    def removeFiringRange(self, firingRange):
        self.__firingRange = [x for x in self.__firingRange if x not in firingRange]
        return self.__firingRange
    def getFiringRange(self, firingRange = 0):
        return self.__firingRange
    def firingRange_changed(self, firingRange = 0):
        return self.__firingRange
    @property
    def firingRate(self):
        return self.__firingRate
    @firingRate.setter
    def firingRate(self, value = 0):
        self.__firingRate = [value]
    def setFiringRate(self, firingRate = 0):
        self.__firingRate = [firingRate]
        return self
    def addFiringRate(self, firingRate = 0):
        if self.__firingRate == None:            self.__firingRate =  []
        self.__firingRate +=  [firingRate]
        return self
    def removeFiringRate(self, firingRate):
        self.__firingRate = [x for x in self.__firingRate if x not in firingRate]
        return self.__firingRate
    def getFiringRate(self, firingRate = 0):
        return self.__firingRate
    def firingRate_changed(self, firingRate = 0):
        return self.__firingRate
    @property
    def forceID(self):
        return self.__forceID
    @forceID.setter
    def forceID(self, value = 0):
        self.__forceID = [value]
    def setForceID(self, forceID = 0):
        self.__forceID = [forceID]
        return self
    def addForceID(self, forceID = 0):
        if self.__forceID == None:            self.__forceID =  []
        self.__forceID +=  [forceID]
        return self
    def removeForceID(self, forceID):
        self.__forceID = [x for x in self.__forceID if x not in forceID]
        return self.__forceID
    def getForceID(self, forceID = 0):
        return self.__forceID
    def forceID_changed(self, forceID = 0):
        return self.__forceID
    @property
    def fuse(self):
        return self.__fuse
    @fuse.setter
    def fuse(self, value = 0):
        self.__fuse = [value]
    def setFuse(self, fuse = 0):
        self.__fuse = [fuse]
        return self
    def addFuse(self, fuse = 0):
        if self.__fuse == None:            self.__fuse =  []
        self.__fuse +=  [fuse]
        return self
    def removeFuse(self, fuse):
        self.__fuse = [x for x in self.__fuse if x not in fuse]
        return self.__fuse
    def getFuse(self, fuse = 0):
        return self.__fuse
    def fuse_changed(self, fuse = 0):
        return self.__fuse
    @property
    def geoCoords(self):
        return self.__geoCoords
    @geoCoords.setter
    def geoCoords(self, value = [0, 0, 0]):
        self.__geoCoords = [value]
    def setGeoCoords(self, geoCoords = [0, 0, 0]):
        self.__geoCoords = [geoCoords]
        return self
    def addGeoCoords(self, geoCoords = [0, 0, 0]):
        if self.__geoCoords == None:            self.__geoCoords =  []
        self.__geoCoords +=  [geoCoords]
        return self
    def removeGeoCoords(self, geoCoords):
        self.__geoCoords = [x for x in self.__geoCoords if x not in geoCoords]
        return self.__geoCoords
    def getGeoCoords(self, geoCoords = [0, 0, 0]):
        return self.__geoCoords
    def geoCoords_changed(self, geoCoords = [0, 0, 0]):
        return self.__geoCoords
    def isActive(self, Active = None):
        return self.__Active
    def isCollided(self, Collided = None):
        return self.__Collided
    def isDetonated(self, Detonated = None):
        return self.__Detonated
    def isNetworkReader(self, NetworkReader = None):
        return self.__NetworkReader
    def isNetworkWriter(self, NetworkWriter = None):
        return self.__NetworkWriter
    def isRtpHeaderHeard(self, RtpHeaderHeard = None):
        return self.__RtpHeaderHeard
    def isStandAlone(self, StandAlone = None):
        return self.__StandAlone
    @property
    def linearAcceleration(self):
        return self.__linearAcceleration
    @linearAcceleration.setter
    def linearAcceleration(self, value = [0, 0, 0]):
        self.__linearAcceleration = [value]
    def setLinearAcceleration(self, linearAcceleration = [0, 0, 0]):
        self.__linearAcceleration = [linearAcceleration]
        return self
    def addLinearAcceleration(self, linearAcceleration = [0, 0, 0]):
        if self.__linearAcceleration == None:            self.__linearAcceleration =  []
        self.__linearAcceleration +=  [linearAcceleration]
        return self
    def removeLinearAcceleration(self, linearAcceleration):
        self.__linearAcceleration = [x for x in self.__linearAcceleration if x not in linearAcceleration]
        return self.__linearAcceleration
    def getLinearAcceleration(self, linearAcceleration = [0, 0, 0]):
        return self.__linearAcceleration
    def linearAcceleration_changed(self, linearAcceleration = [0, 0, 0]):
        return self.__linearAcceleration
    @property
    def linearVelocity(self):
        return self.__linearVelocity
    @linearVelocity.setter
    def linearVelocity(self, value = [0, 0, 0]):
        self.__linearVelocity = [value]
    def setLinearVelocity(self, linearVelocity = [0, 0, 0]):
        self.__linearVelocity = [linearVelocity]
        return self
    def addLinearVelocity(self, linearVelocity = [0, 0, 0]):
        if self.__linearVelocity == None:            self.__linearVelocity =  []
        self.__linearVelocity +=  [linearVelocity]
        return self
    def removeLinearVelocity(self, linearVelocity):
        self.__linearVelocity = [x for x in self.__linearVelocity if x not in linearVelocity]
        return self.__linearVelocity
    def getLinearVelocity(self, linearVelocity = [0, 0, 0]):
        return self.__linearVelocity
    def linearVelocity_changed(self, linearVelocity = [0, 0, 0]):
        return self.__linearVelocity
    @property
    def marking(self):
        return self.__marking
    @marking.setter
    def marking(self, value = None):
        self.__marking = [value]
    def setMarking(self, marking = None):
        self.__marking = [marking]
        return self
    def addMarking(self, marking = None):
        if self.__marking == None:            self.__marking =  []
        self.__marking +=  [marking]
        return self
    def removeMarking(self, marking):
        self.__marking = [x for x in self.__marking if x not in marking]
        return self.__marking
    def getMarking(self, marking = None):
        return self.__marking
    def marking_changed(self, marking = None):
        return self.__marking
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def multicastRelayHost(self):
        return self.__multicastRelayHost
    @multicastRelayHost.setter
    def multicastRelayHost(self, value = None):
        self.__multicastRelayHost = [value]
    def setMulticastRelayHost(self, multicastRelayHost = None):
        self.__multicastRelayHost = [multicastRelayHost]
        return self
    def addMulticastRelayHost(self, multicastRelayHost = None):
        if self.__multicastRelayHost == None:            self.__multicastRelayHost =  []
        self.__multicastRelayHost +=  [multicastRelayHost]
        return self
    def removeMulticastRelayHost(self, multicastRelayHost):
        self.__multicastRelayHost = [x for x in self.__multicastRelayHost if x not in multicastRelayHost]
        return self.__multicastRelayHost
    def getMulticastRelayHost(self, multicastRelayHost = None):
        return self.__multicastRelayHost
    def multicastRelayHost_changed(self, multicastRelayHost = None):
        return self.__multicastRelayHost
    @property
    def multicastRelayPort(self):
        return self.__multicastRelayPort
    @multicastRelayPort.setter
    def multicastRelayPort(self, value = 0):
        self.__multicastRelayPort = [value]
    def setMulticastRelayPort(self, multicastRelayPort = 0):
        self.__multicastRelayPort = [multicastRelayPort]
        return self
    def addMulticastRelayPort(self, multicastRelayPort = 0):
        if self.__multicastRelayPort == None:            self.__multicastRelayPort =  []
        self.__multicastRelayPort +=  [multicastRelayPort]
        return self
    def removeMulticastRelayPort(self, multicastRelayPort):
        self.__multicastRelayPort = [x for x in self.__multicastRelayPort if x not in multicastRelayPort]
        return self.__multicastRelayPort
    def getMulticastRelayPort(self, multicastRelayPort = 0):
        return self.__multicastRelayPort
    def multicastRelayPort_changed(self, multicastRelayPort = 0):
        return self.__multicastRelayPort
    @property
    def munitionApplicationID(self):
        return self.__munitionApplicationID
    @munitionApplicationID.setter
    def munitionApplicationID(self, value = 0):
        self.__munitionApplicationID = [value]
    def setMunitionApplicationID(self, munitionApplicationID = 0):
        self.__munitionApplicationID = [munitionApplicationID]
        return self
    def addMunitionApplicationID(self, munitionApplicationID = 0):
        if self.__munitionApplicationID == None:            self.__munitionApplicationID =  []
        self.__munitionApplicationID +=  [munitionApplicationID]
        return self
    def removeMunitionApplicationID(self, munitionApplicationID):
        self.__munitionApplicationID = [x for x in self.__munitionApplicationID if x not in munitionApplicationID]
        return self.__munitionApplicationID
    def getMunitionApplicationID(self, munitionApplicationID = 0):
        return self.__munitionApplicationID
    def munitionApplicationID_changed(self, munitionApplicationID = 0):
        return self.__munitionApplicationID
    @property
    def munitionEndPoint(self):
        return self.__munitionEndPoint
    @munitionEndPoint.setter
    def munitionEndPoint(self, value = [0, 0, 0]):
        self.__munitionEndPoint = [value]
    def setMunitionEndPoint(self, munitionEndPoint = [0, 0, 0]):
        self.__munitionEndPoint = [munitionEndPoint]
        return self
    def addMunitionEndPoint(self, munitionEndPoint = [0, 0, 0]):
        if self.__munitionEndPoint == None:            self.__munitionEndPoint =  []
        self.__munitionEndPoint +=  [munitionEndPoint]
        return self
    def removeMunitionEndPoint(self, munitionEndPoint):
        self.__munitionEndPoint = [x for x in self.__munitionEndPoint if x not in munitionEndPoint]
        return self.__munitionEndPoint
    def getMunitionEndPoint(self, munitionEndPoint = [0, 0, 0]):
        return self.__munitionEndPoint
    def munitionEndPoint_changed(self, munitionEndPoint = [0, 0, 0]):
        return self.__munitionEndPoint
    @property
    def munitionEntityID(self):
        return self.__munitionEntityID
    @munitionEntityID.setter
    def munitionEntityID(self, value = 0):
        self.__munitionEntityID = [value]
    def setMunitionEntityID(self, munitionEntityID = 0):
        self.__munitionEntityID = [munitionEntityID]
        return self
    def addMunitionEntityID(self, munitionEntityID = 0):
        if self.__munitionEntityID == None:            self.__munitionEntityID =  []
        self.__munitionEntityID +=  [munitionEntityID]
        return self
    def removeMunitionEntityID(self, munitionEntityID):
        self.__munitionEntityID = [x for x in self.__munitionEntityID if x not in munitionEntityID]
        return self.__munitionEntityID
    def getMunitionEntityID(self, munitionEntityID = 0):
        return self.__munitionEntityID
    def munitionEntityID_changed(self, munitionEntityID = 0):
        return self.__munitionEntityID
    @property
    def munitionQuantity(self):
        return self.__munitionQuantity
    @munitionQuantity.setter
    def munitionQuantity(self, value = 0):
        self.__munitionQuantity = [value]
    def setMunitionQuantity(self, munitionQuantity = 0):
        self.__munitionQuantity = [munitionQuantity]
        return self
    def addMunitionQuantity(self, munitionQuantity = 0):
        if self.__munitionQuantity == None:            self.__munitionQuantity =  []
        self.__munitionQuantity +=  [munitionQuantity]
        return self
    def removeMunitionQuantity(self, munitionQuantity):
        self.__munitionQuantity = [x for x in self.__munitionQuantity if x not in munitionQuantity]
        return self.__munitionQuantity
    def getMunitionQuantity(self, munitionQuantity = 0):
        return self.__munitionQuantity
    def munitionQuantity_changed(self, munitionQuantity = 0):
        return self.__munitionQuantity
    @property
    def munitionSiteID(self):
        return self.__munitionSiteID
    @munitionSiteID.setter
    def munitionSiteID(self, value = 0):
        self.__munitionSiteID = [value]
    def setMunitionSiteID(self, munitionSiteID = 0):
        self.__munitionSiteID = [munitionSiteID]
        return self
    def addMunitionSiteID(self, munitionSiteID = 0):
        if self.__munitionSiteID == None:            self.__munitionSiteID =  []
        self.__munitionSiteID +=  [munitionSiteID]
        return self
    def removeMunitionSiteID(self, munitionSiteID):
        self.__munitionSiteID = [x for x in self.__munitionSiteID if x not in munitionSiteID]
        return self.__munitionSiteID
    def getMunitionSiteID(self, munitionSiteID = 0):
        return self.__munitionSiteID
    def munitionSiteID_changed(self, munitionSiteID = 0):
        return self.__munitionSiteID
    @property
    def munitionStartPoint(self):
        return self.__munitionStartPoint
    @munitionStartPoint.setter
    def munitionStartPoint(self, value = [0, 0, 0]):
        self.__munitionStartPoint = [value]
    def setMunitionStartPoint(self, munitionStartPoint = [0, 0, 0]):
        self.__munitionStartPoint = [munitionStartPoint]
        return self
    def addMunitionStartPoint(self, munitionStartPoint = [0, 0, 0]):
        if self.__munitionStartPoint == None:            self.__munitionStartPoint =  []
        self.__munitionStartPoint +=  [munitionStartPoint]
        return self
    def removeMunitionStartPoint(self, munitionStartPoint):
        self.__munitionStartPoint = [x for x in self.__munitionStartPoint if x not in munitionStartPoint]
        return self.__munitionStartPoint
    def getMunitionStartPoint(self, munitionStartPoint = [0, 0, 0]):
        return self.__munitionStartPoint
    def munitionStartPoint_changed(self, munitionStartPoint = [0, 0, 0]):
        return self.__munitionStartPoint
    @property
    def networkMode(self):
        return self.__networkMode
    @networkMode.setter
    def networkMode(self, value = "standAlone"):
        if 'standAlone' == value:
            pass
        elif 'networkReader' == value:
            pass
        elif 'networkWriter' == value:
            pass
        else:
            return None
        self.__networkMode = [value]
    def setNetworkMode(self, networkMode = "standAlone"):
        if 'standAlone' == networkMode:
            pass
        elif 'networkReader' == networkMode:
            pass
        elif 'networkWriter' == networkMode:
            pass
        else:
            return None
        self.__networkMode = [networkMode]
        return self
    def addNetworkMode(self, networkMode = "standAlone"):
        if 'standAlone' == networkMode:
            pass
        elif 'networkReader' == networkMode:
            pass
        elif 'networkWriter' == networkMode:
            pass
        else:
            return None
        if self.__networkMode == None:            self.__networkMode =  []
        self.__networkMode +=  [networkMode]
        return self
    def removeNetworkMode(self, networkMode):
        self.__networkMode = [x for x in self.__networkMode if x not in networkMode]
        return self.__networkMode
    def getNetworkMode(self, networkMode = "standAlone"):
        return self.__networkMode
    def networkMode_changed(self, networkMode = "standAlone"):
        return self.__networkMode
    @property
    def port(self):
        return self.__port
    @port.setter
    def port(self, value = 0):
        self.__port = [value]
    def setPort(self, port = 0):
        self.__port = [port]
        return self
    def addPort(self, port = 0):
        if self.__port == None:            self.__port =  []
        self.__port +=  [port]
        return self
    def removePort(self, port):
        self.__port = [x for x in self.__port if x not in port]
        return self.__port
    def getPort(self, port = 0):
        return self.__port
    def port_changed(self, port = 0):
        return self.__port
    @property
    def readInterval(self):
        return self.__readInterval
    @readInterval.setter
    def readInterval(self, value = 0.1):
        if value == None or value  <  0:
            return None
        self.__readInterval = [value]
    def setReadInterval(self, readInterval = 0.1):
        if readInterval == None or readInterval  <  0:
            return None
        self.__readInterval = [readInterval]
        return self
    def addReadInterval(self, readInterval = 0.1):
        if readInterval == None or readInterval  <  0:
            return None
        if self.__readInterval == None:            self.__readInterval =  []
        self.__readInterval +=  [readInterval]
        return self
    def removeReadInterval(self, readInterval):
        self.__readInterval = [x for x in self.__readInterval if x not in readInterval]
        return self.__readInterval
    def getReadInterval(self, readInterval = 0.1):
        return self.__readInterval
    def readInterval_changed(self, readInterval = 0.1):
        return self.__readInterval
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    @property
    def rotation(self):
        return self.__rotation
    @rotation.setter
    def rotation(self, value = [0, 0, 1, 0]):
        self.__rotation = [value]
    def setRotation(self, rotation = [0, 0, 1, 0]):
        self.__rotation = [rotation]
        return self
    def addRotation(self, rotation = [0, 0, 1, 0]):
        if self.__rotation == None:            self.__rotation =  []
        self.__rotation +=  [rotation]
        return self
    def removeRotation(self, rotation):
        self.__rotation = [x for x in self.__rotation if x not in rotation]
        return self.__rotation
    def getRotation(self, rotation = [0, 0, 1, 0]):
        return self.__rotation
    def rotation_changed(self, rotation = [0, 0, 1, 0]):
        return self.__rotation
    @property
    def scale(self):
        return self.__scale
    @scale.setter
    def scale(self, value = [1, 1, 1]):
        self.__scale = [value]
    def setScale(self, scale = [1, 1, 1]):
        self.__scale = [scale]
        return self
    def addScale(self, scale = [1, 1, 1]):
        if self.__scale == None:            self.__scale =  []
        self.__scale +=  [scale]
        return self
    def removeScale(self, scale):
        self.__scale = [x for x in self.__scale if x not in scale]
        return self.__scale
    def getScale(self, scale = [1, 1, 1]):
        return self.__scale
    def scale_changed(self, scale = [1, 1, 1]):
        return self.__scale
    @property
    def scaleOrientation(self):
        return self.__scaleOrientation
    @scaleOrientation.setter
    def scaleOrientation(self, value = [0, 0, 1, 0]):
        self.__scaleOrientation = [value]
    def setScaleOrientation(self, scaleOrientation = [0, 0, 1, 0]):
        self.__scaleOrientation = [scaleOrientation]
        return self
    def addScaleOrientation(self, scaleOrientation = [0, 0, 1, 0]):
        if self.__scaleOrientation == None:            self.__scaleOrientation =  []
        self.__scaleOrientation +=  [scaleOrientation]
        return self
    def removeScaleOrientation(self, scaleOrientation):
        self.__scaleOrientation = [x for x in self.__scaleOrientation if x not in scaleOrientation]
        return self.__scaleOrientation
    def getScaleOrientation(self, scaleOrientation = [0, 0, 1, 0]):
        return self.__scaleOrientation
    def scaleOrientation_changed(self, scaleOrientation = [0, 0, 1, 0]):
        return self.__scaleOrientation
    @property
    def articulationParameterValue0(self):
        return self.__articulationParameterValue0
    @articulationParameterValue0.setter
    def articulationParameterValue0(self, value = None):
        self.__articulationParameterValue0 = [value]
    def set_articulationParameterValue0(self, articulationParameterValue0 = None):
        self.__articulationParameterValue0 = [articulationParameterValue0]
        return self
    @property
    def articulationParameterValue1(self):
        return self.__articulationParameterValue1
    @articulationParameterValue1.setter
    def articulationParameterValue1(self, value = None):
        self.__articulationParameterValue1 = [value]
    def set_articulationParameterValue1(self, articulationParameterValue1 = None):
        self.__articulationParameterValue1 = [articulationParameterValue1]
        return self
    @property
    def articulationParameterValue2(self):
        return self.__articulationParameterValue2
    @articulationParameterValue2.setter
    def articulationParameterValue2(self, value = None):
        self.__articulationParameterValue2 = [value]
    def set_articulationParameterValue2(self, articulationParameterValue2 = None):
        self.__articulationParameterValue2 = [articulationParameterValue2]
        return self
    @property
    def articulationParameterValue3(self):
        return self.__articulationParameterValue3
    @articulationParameterValue3.setter
    def articulationParameterValue3(self, value = None):
        self.__articulationParameterValue3 = [value]
    def set_articulationParameterValue3(self, articulationParameterValue3 = None):
        self.__articulationParameterValue3 = [articulationParameterValue3]
        return self
    @property
    def articulationParameterValue4(self):
        return self.__articulationParameterValue4
    @articulationParameterValue4.setter
    def articulationParameterValue4(self, value = None):
        self.__articulationParameterValue4 = [value]
    def set_articulationParameterValue4(self, articulationParameterValue4 = None):
        self.__articulationParameterValue4 = [articulationParameterValue4]
        return self
    @property
    def articulationParameterValue5(self):
        return self.__articulationParameterValue5
    @articulationParameterValue5.setter
    def articulationParameterValue5(self, value = None):
        self.__articulationParameterValue5 = [value]
    def set_articulationParameterValue5(self, articulationParameterValue5 = None):
        self.__articulationParameterValue5 = [articulationParameterValue5]
        return self
    @property
    def articulationParameterValue6(self):
        return self.__articulationParameterValue6
    @articulationParameterValue6.setter
    def articulationParameterValue6(self, value = None):
        self.__articulationParameterValue6 = [value]
    def set_articulationParameterValue6(self, articulationParameterValue6 = None):
        self.__articulationParameterValue6 = [articulationParameterValue6]
        return self
    @property
    def articulationParameterValue7(self):
        return self.__articulationParameterValue7
    @articulationParameterValue7.setter
    def articulationParameterValue7(self, value = None):
        self.__articulationParameterValue7 = [value]
    def set_articulationParameterValue7(self, articulationParameterValue7 = None):
        self.__articulationParameterValue7 = [articulationParameterValue7]
        return self
    @property
    def siteID(self):
        return self.__siteID
    @siteID.setter
    def siteID(self, value = 0):
        self.__siteID = [value]
    def setSiteID(self, siteID = 0):
        self.__siteID = [siteID]
        return self
    def addSiteID(self, siteID = 0):
        if self.__siteID == None:            self.__siteID =  []
        self.__siteID +=  [siteID]
        return self
    def removeSiteID(self, siteID):
        self.__siteID = [x for x in self.__siteID if x not in siteID]
        return self.__siteID
    def getSiteID(self, siteID = 0):
        return self.__siteID
    def siteID_changed(self, siteID = 0):
        return self.__siteID
    def removeTimestamp(self, timestamp):
        self.__timestamp = [x for x in self.__timestamp if x not in timestamp]
        return self.__timestamp
    def getTimestamp(self, timestamp = None):
        return self.__timestamp
    def timestamp_changed(self, timestamp = None):
        return self.__timestamp
    @property
    def translation(self):
        return self.__translation
    @translation.setter
    def translation(self, value = [0, 0, 0]):
        self.__translation = [value]
    def setTranslation(self, translation = [0, 0, 0]):
        self.__translation = [translation]
        return self
    def addTranslation(self, translation = [0, 0, 0]):
        if self.__translation == None:            self.__translation =  []
        self.__translation +=  [translation]
        return self
    def removeTranslation(self, translation):
        self.__translation = [x for x in self.__translation if x not in translation]
        return self.__translation
    def getTranslation(self, translation = [0, 0, 0]):
        return self.__translation
    def translation_changed(self, translation = [0, 0, 0]):
        return self.__translation
    @property
    def warhead(self):
        return self.__warhead
    @warhead.setter
    def warhead(self, value = 0):
        self.__warhead = [value]
    def setWarhead(self, warhead = 0):
        self.__warhead = [warhead]
        return self
    def addWarhead(self, warhead = 0):
        if self.__warhead == None:            self.__warhead =  []
        self.__warhead +=  [warhead]
        return self
    def removeWarhead(self, warhead):
        self.__warhead = [x for x in self.__warhead if x not in warhead]
        return self.__warhead
    def getWarhead(self, warhead = 0):
        return self.__warhead
    def warhead_changed(self, warhead = 0):
        return self.__warhead
    @property
    def writeInterval(self):
        return self.__writeInterval
    @writeInterval.setter
    def writeInterval(self, value = 1.0):
        if value == None or value  <  0:
            return None
        self.__writeInterval = [value]
    def setWriteInterval(self, writeInterval = 1.0):
        if writeInterval == None or writeInterval  <  0:
            return None
        self.__writeInterval = [writeInterval]
        return self
    def addWriteInterval(self, writeInterval = 1.0):
        if writeInterval == None or writeInterval  <  0:
            return None
        if self.__writeInterval == None:            self.__writeInterval =  []
        self.__writeInterval +=  [writeInterval]
        return self
    def removeWriteInterval(self, writeInterval):
        self.__writeInterval = [x for x in self.__writeInterval if x not in writeInterval]
        return self.__writeInterval
    def getWriteInterval(self, writeInterval = 1.0):
        return self.__writeInterval
    def writeInterval_changed(self, writeInterval = 1.0):
        return self.__writeInterval
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<EspduTransform'
        if self.__address is not None:
            if isinstance(self.__address, six.string_types):
                str += ' address="'+self.__address+'"'
            else:
                str += ' address="'+self.__address[0]+'"'
        if self.__applicationID is not None:
            if isinstance(self.__applicationID, six.string_types):
                str += ' applicationID="'+self.__applicationID+'"'
            else:
                str += ' applicationID="'+self.__applicationID[0]+'"'
        if self.__articulationParameterArray is not None:
            if isinstance(self.__articulationParameterArray, six.string_types):
                str += ' articulationParameterArray="'+self.__articulationParameterArray+'"'
            else:
                str += ' articulationParameterArray="'+self.__articulationParameterArray[0]+'"'
        if self.__articulationParameterChangeIndicatorArray is not None:
            if isinstance(self.__articulationParameterChangeIndicatorArray, six.string_types):
                str += ' articulationParameterChangeIndicatorArray="'+self.__articulationParameterChangeIndicatorArray+'"'
            else:
                str += ' articulationParameterChangeIndicatorArray="'+self.__articulationParameterChangeIndicatorArray[0]+'"'
        if self.__articulationParameterCount is not None:
            if isinstance(self.__articulationParameterCount, six.string_types):
                str += ' articulationParameterCount="'+self.__articulationParameterCount+'"'
            else:
                str += ' articulationParameterCount="'+self.__articulationParameterCount[0]+'"'
        if self.__articulationParameterDesignatorArray is not None:
            if isinstance(self.__articulationParameterDesignatorArray, six.string_types):
                str += ' articulationParameterDesignatorArray="'+self.__articulationParameterDesignatorArray+'"'
            else:
                str += ' articulationParameterDesignatorArray="'+self.__articulationParameterDesignatorArray[0]+'"'
        if self.__articulationParameterIdPartAttachedToArray is not None:
            if isinstance(self.__articulationParameterIdPartAttachedToArray, six.string_types):
                str += ' articulationParameterIdPartAttachedToArray="'+self.__articulationParameterIdPartAttachedToArray+'"'
            else:
                str += ' articulationParameterIdPartAttachedToArray="'+self.__articulationParameterIdPartAttachedToArray[0]+'"'
        if self.__articulationParameterTypeArray is not None:
            if isinstance(self.__articulationParameterTypeArray, six.string_types):
                str += ' articulationParameterTypeArray="'+self.__articulationParameterTypeArray+'"'
            else:
                str += ' articulationParameterTypeArray="'+self.__articulationParameterTypeArray[0]+'"'
        if self.__articulationParameterValue0_changed is not None:
            if isinstance(self.__articulationParameterValue0_changed, six.string_types):
                str += ' articulationParameterValue0_changed="'+self.__articulationParameterValue0_changed+'"'
            else:
                str += ' articulationParameterValue0_changed="'+self.__articulationParameterValue0_changed[0]+'"'
        if self.__articulationParameterValue1_changed is not None:
            if isinstance(self.__articulationParameterValue1_changed, six.string_types):
                str += ' articulationParameterValue1_changed="'+self.__articulationParameterValue1_changed+'"'
            else:
                str += ' articulationParameterValue1_changed="'+self.__articulationParameterValue1_changed[0]+'"'
        if self.__articulationParameterValue2_changed is not None:
            if isinstance(self.__articulationParameterValue2_changed, six.string_types):
                str += ' articulationParameterValue2_changed="'+self.__articulationParameterValue2_changed+'"'
            else:
                str += ' articulationParameterValue2_changed="'+self.__articulationParameterValue2_changed[0]+'"'
        if self.__articulationParameterValue3_changed is not None:
            if isinstance(self.__articulationParameterValue3_changed, six.string_types):
                str += ' articulationParameterValue3_changed="'+self.__articulationParameterValue3_changed+'"'
            else:
                str += ' articulationParameterValue3_changed="'+self.__articulationParameterValue3_changed[0]+'"'
        if self.__articulationParameterValue4_changed is not None:
            if isinstance(self.__articulationParameterValue4_changed, six.string_types):
                str += ' articulationParameterValue4_changed="'+self.__articulationParameterValue4_changed+'"'
            else:
                str += ' articulationParameterValue4_changed="'+self.__articulationParameterValue4_changed[0]+'"'
        if self.__articulationParameterValue5_changed is not None:
            if isinstance(self.__articulationParameterValue5_changed, six.string_types):
                str += ' articulationParameterValue5_changed="'+self.__articulationParameterValue5_changed+'"'
            else:
                str += ' articulationParameterValue5_changed="'+self.__articulationParameterValue5_changed[0]+'"'
        if self.__articulationParameterValue6_changed is not None:
            if isinstance(self.__articulationParameterValue6_changed, six.string_types):
                str += ' articulationParameterValue6_changed="'+self.__articulationParameterValue6_changed+'"'
            else:
                str += ' articulationParameterValue6_changed="'+self.__articulationParameterValue6_changed[0]+'"'
        if self.__articulationParameterValue7_changed is not None:
            if isinstance(self.__articulationParameterValue7_changed, six.string_types):
                str += ' articulationParameterValue7_changed="'+self.__articulationParameterValue7_changed+'"'
            else:
                str += ' articulationParameterValue7_changed="'+self.__articulationParameterValue7_changed[0]+'"'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__center is not None:
            if isinstance(self.__center, six.string_types):
                str += ' center="'+self.__center+'"'
            else:
                str += ' center="'+self.__center[0]+'"'
        if self.__collideTime is not None:
            if isinstance(self.__collideTime, six.string_types):
                str += ' collideTime="'+self.__collideTime+'"'
            else:
                str += ' collideTime="'+self.__collideTime[0]+'"'
        if self.__collisionType is not None:
            if isinstance(self.__collisionType, six.string_types):
                str += ' collisionType="'+self.__collisionType+'"'
            else:
                str += ' collisionType="'+self.__collisionType[0]+'"'
        if self.__deadReckoning is not None:
            if isinstance(self.__deadReckoning, six.string_types):
                str += ' deadReckoning="'+self.__deadReckoning+'"'
            else:
                str += ' deadReckoning="'+self.__deadReckoning[0]+'"'
        if self.__detonateTime is not None:
            if isinstance(self.__detonateTime, six.string_types):
                str += ' detonateTime="'+self.__detonateTime+'"'
            else:
                str += ' detonateTime="'+self.__detonateTime[0]+'"'
        if self.__detonationLocation is not None:
            if isinstance(self.__detonationLocation, six.string_types):
                str += ' detonationLocation="'+self.__detonationLocation+'"'
            else:
                str += ' detonationLocation="'+self.__detonationLocation[0]+'"'
        if self.__detonationRelativeLocation is not None:
            if isinstance(self.__detonationRelativeLocation, six.string_types):
                str += ' detonationRelativeLocation="'+self.__detonationRelativeLocation+'"'
            else:
                str += ' detonationRelativeLocation="'+self.__detonationRelativeLocation[0]+'"'
        if self.__detonationResult is not None:
            if isinstance(self.__detonationResult, six.string_types):
                str += ' detonationResult="'+self.__detonationResult+'"'
            else:
                str += ' detonationResult="'+self.__detonationResult[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__entityCategory is not None:
            if isinstance(self.__entityCategory, six.string_types):
                str += ' entityCategory="'+self.__entityCategory+'"'
            else:
                str += ' entityCategory="'+self.__entityCategory[0]+'"'
        if self.__entityCountry is not None:
            if isinstance(self.__entityCountry, six.string_types):
                str += ' entityCountry="'+self.__entityCountry+'"'
            else:
                str += ' entityCountry="'+self.__entityCountry[0]+'"'
        if self.__entityDomain is not None:
            if isinstance(self.__entityDomain, six.string_types):
                str += ' entityDomain="'+self.__entityDomain+'"'
            else:
                str += ' entityDomain="'+self.__entityDomain[0]+'"'
        if self.__entityExtra is not None:
            if isinstance(self.__entityExtra, six.string_types):
                str += ' entityExtra="'+self.__entityExtra+'"'
            else:
                str += ' entityExtra="'+self.__entityExtra[0]+'"'
        if self.__entityID is not None:
            if isinstance(self.__entityID, six.string_types):
                str += ' entityID="'+self.__entityID+'"'
            else:
                str += ' entityID="'+self.__entityID[0]+'"'
        if self.__entityKind is not None:
            if isinstance(self.__entityKind, six.string_types):
                str += ' entityKind="'+self.__entityKind+'"'
            else:
                str += ' entityKind="'+self.__entityKind[0]+'"'
        if self.__entitySpecific is not None:
            if isinstance(self.__entitySpecific, six.string_types):
                str += ' entitySpecific="'+self.__entitySpecific+'"'
            else:
                str += ' entitySpecific="'+self.__entitySpecific[0]+'"'
        if self.__entitySubcategory is not None:
            if isinstance(self.__entitySubcategory, six.string_types):
                str += ' entitySubcategory="'+self.__entitySubcategory+'"'
            else:
                str += ' entitySubcategory="'+self.__entitySubcategory[0]+'"'
        if self.__eventApplicationID is not None:
            if isinstance(self.__eventApplicationID, six.string_types):
                str += ' eventApplicationID="'+self.__eventApplicationID+'"'
            else:
                str += ' eventApplicationID="'+self.__eventApplicationID[0]+'"'
        if self.__eventEntityID is not None:
            if isinstance(self.__eventEntityID, six.string_types):
                str += ' eventEntityID="'+self.__eventEntityID+'"'
            else:
                str += ' eventEntityID="'+self.__eventEntityID[0]+'"'
        if self.__eventNumber is not None:
            if isinstance(self.__eventNumber, six.string_types):
                str += ' eventNumber="'+self.__eventNumber+'"'
            else:
                str += ' eventNumber="'+self.__eventNumber[0]+'"'
        if self.__eventSiteID is not None:
            if isinstance(self.__eventSiteID, six.string_types):
                str += ' eventSiteID="'+self.__eventSiteID+'"'
            else:
                str += ' eventSiteID="'+self.__eventSiteID[0]+'"'
        if self.__fired1 is not None:
            if isinstance(self.__fired1, six.string_types):
                str += ' fired1="'+self.__fired1+'"'
            else:
                str += ' fired1="'+self.__fired1[0]+'"'
        if self.__fired2 is not None:
            if isinstance(self.__fired2, six.string_types):
                str += ' fired2="'+self.__fired2+'"'
            else:
                str += ' fired2="'+self.__fired2[0]+'"'
        if self.__firedTime is not None:
            if isinstance(self.__firedTime, six.string_types):
                str += ' firedTime="'+self.__firedTime+'"'
            else:
                str += ' firedTime="'+self.__firedTime[0]+'"'
        if self.__fireMissionIndex is not None:
            if isinstance(self.__fireMissionIndex, six.string_types):
                str += ' fireMissionIndex="'+self.__fireMissionIndex+'"'
            else:
                str += ' fireMissionIndex="'+self.__fireMissionIndex[0]+'"'
        if self.__firingRange is not None:
            if isinstance(self.__firingRange, six.string_types):
                str += ' firingRange="'+self.__firingRange+'"'
            else:
                str += ' firingRange="'+self.__firingRange[0]+'"'
        if self.__firingRate is not None:
            if isinstance(self.__firingRate, six.string_types):
                str += ' firingRate="'+self.__firingRate+'"'
            else:
                str += ' firingRate="'+self.__firingRate[0]+'"'
        if self.__forceID is not None:
            if isinstance(self.__forceID, six.string_types):
                str += ' forceID="'+self.__forceID+'"'
            else:
                str += ' forceID="'+self.__forceID[0]+'"'
        if self.__fuse is not None:
            if isinstance(self.__fuse, six.string_types):
                str += ' fuse="'+self.__fuse+'"'
            else:
                str += ' fuse="'+self.__fuse[0]+'"'
        if self.__geoCoords is not None:
            if isinstance(self.__geoCoords, six.string_types):
                str += ' geoCoords="'+self.__geoCoords+'"'
            else:
                str += ' geoCoords="'+self.__geoCoords[0]+'"'
        if self.__geoSystem is not None:
            if isinstance(self.__geoSystem, six.string_types):
                str += ' geoSystem="'+self.__geoSystem+'"'
            else:
                str += ' geoSystem="'+self.__geoSystem[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__Collided is not None:
            if isinstance(self.__Collided, six.string_types):
                str += ' Collided="'+self.__Collided+'"'
            else:
                str += ' Collided="'+self.__Collided[0]+'"'
        if self.__Detonated is not None:
            if isinstance(self.__Detonated, six.string_types):
                str += ' Detonated="'+self.__Detonated+'"'
            else:
                str += ' Detonated="'+self.__Detonated[0]+'"'
        if self.__NetworkReader is not None:
            if isinstance(self.__NetworkReader, six.string_types):
                str += ' NetworkReader="'+self.__NetworkReader+'"'
            else:
                str += ' NetworkReader="'+self.__NetworkReader[0]+'"'
        if self.__NetworkWriter is not None:
            if isinstance(self.__NetworkWriter, six.string_types):
                str += ' NetworkWriter="'+self.__NetworkWriter+'"'
            else:
                str += ' NetworkWriter="'+self.__NetworkWriter[0]+'"'
        if self.__RtpHeaderHeard is not None:
            if isinstance(self.__RtpHeaderHeard, six.string_types):
                str += ' RtpHeaderHeard="'+self.__RtpHeaderHeard+'"'
            else:
                str += ' RtpHeaderHeard="'+self.__RtpHeaderHeard[0]+'"'
        if self.__StandAlone is not None:
            if isinstance(self.__StandAlone, six.string_types):
                str += ' StandAlone="'+self.__StandAlone+'"'
            else:
                str += ' StandAlone="'+self.__StandAlone[0]+'"'
        if self.__linearAcceleration is not None:
            if isinstance(self.__linearAcceleration, six.string_types):
                str += ' linearAcceleration="'+self.__linearAcceleration+'"'
            else:
                str += ' linearAcceleration="'+self.__linearAcceleration[0]+'"'
        if self.__linearVelocity is not None:
            if isinstance(self.__linearVelocity, six.string_types):
                str += ' linearVelocity="'+self.__linearVelocity+'"'
            else:
                str += ' linearVelocity="'+self.__linearVelocity[0]+'"'
        if self.__marking is not None:
            if isinstance(self.__marking, six.string_types):
                str += ' marking="'+self.__marking+'"'
            else:
                str += ' marking="'+self.__marking[0]+'"'
        if self.__multicastRelayHost is not None:
            if isinstance(self.__multicastRelayHost, six.string_types):
                str += ' multicastRelayHost="'+self.__multicastRelayHost+'"'
            else:
                str += ' multicastRelayHost="'+self.__multicastRelayHost[0]+'"'
        if self.__multicastRelayPort is not None:
            if isinstance(self.__multicastRelayPort, six.string_types):
                str += ' multicastRelayPort="'+self.__multicastRelayPort+'"'
            else:
                str += ' multicastRelayPort="'+self.__multicastRelayPort[0]+'"'
        if self.__munitionApplicationID is not None:
            if isinstance(self.__munitionApplicationID, six.string_types):
                str += ' munitionApplicationID="'+self.__munitionApplicationID+'"'
            else:
                str += ' munitionApplicationID="'+self.__munitionApplicationID[0]+'"'
        if self.__munitionEndPoint is not None:
            if isinstance(self.__munitionEndPoint, six.string_types):
                str += ' munitionEndPoint="'+self.__munitionEndPoint+'"'
            else:
                str += ' munitionEndPoint="'+self.__munitionEndPoint[0]+'"'
        if self.__munitionEntityID is not None:
            if isinstance(self.__munitionEntityID, six.string_types):
                str += ' munitionEntityID="'+self.__munitionEntityID+'"'
            else:
                str += ' munitionEntityID="'+self.__munitionEntityID[0]+'"'
        if self.__munitionQuantity is not None:
            if isinstance(self.__munitionQuantity, six.string_types):
                str += ' munitionQuantity="'+self.__munitionQuantity+'"'
            else:
                str += ' munitionQuantity="'+self.__munitionQuantity[0]+'"'
        if self.__munitionSiteID is not None:
            if isinstance(self.__munitionSiteID, six.string_types):
                str += ' munitionSiteID="'+self.__munitionSiteID+'"'
            else:
                str += ' munitionSiteID="'+self.__munitionSiteID[0]+'"'
        if self.__munitionStartPoint is not None:
            if isinstance(self.__munitionStartPoint, six.string_types):
                str += ' munitionStartPoint="'+self.__munitionStartPoint+'"'
            else:
                str += ' munitionStartPoint="'+self.__munitionStartPoint[0]+'"'
        if self.__networkMode is not None:
            if isinstance(self.__networkMode, six.string_types):
                str += ' networkMode="'+self.__networkMode+'"'
            else:
                str += ' networkMode="'+self.__networkMode[0]+'"'
        if self.__port is not None:
            if isinstance(self.__port, six.string_types):
                str += ' port="'+self.__port+'"'
            else:
                str += ' port="'+self.__port[0]+'"'
        if self.__readInterval is not None:
            if isinstance(self.__readInterval, six.string_types):
                str += ' readInterval="'+self.__readInterval+'"'
            else:
                str += ' readInterval="'+self.__readInterval[0]+'"'
        if self.__rotation is not None:
            if isinstance(self.__rotation, six.string_types):
                str += ' rotation="'+self.__rotation+'"'
            else:
                str += ' rotation="'+self.__rotation[0]+'"'
        if self.__rtpHeaderExpected is not None:
            if isinstance(self.__rtpHeaderExpected, six.string_types):
                str += ' rtpHeaderExpected="'+self.__rtpHeaderExpected+'"'
            else:
                str += ' rtpHeaderExpected="'+self.__rtpHeaderExpected[0]+'"'
        if self.__scale is not None:
            if isinstance(self.__scale, six.string_types):
                str += ' scale="'+self.__scale+'"'
            else:
                str += ' scale="'+self.__scale[0]+'"'
        if self.__scaleOrientation is not None:
            if isinstance(self.__scaleOrientation, six.string_types):
                str += ' scaleOrientation="'+self.__scaleOrientation+'"'
            else:
                str += ' scaleOrientation="'+self.__scaleOrientation[0]+'"'
        if self.__articulationParameterValue0 is not None:
            if isinstance(self.__articulationParameterValue0, six.string_types):
                str += ' articulationParameterValue0="'+self.__articulationParameterValue0+'"'
            else:
                str += ' articulationParameterValue0="'+self.__articulationParameterValue0[0]+'"'
        if self.__articulationParameterValue1 is not None:
            if isinstance(self.__articulationParameterValue1, six.string_types):
                str += ' articulationParameterValue1="'+self.__articulationParameterValue1+'"'
            else:
                str += ' articulationParameterValue1="'+self.__articulationParameterValue1[0]+'"'
        if self.__articulationParameterValue2 is not None:
            if isinstance(self.__articulationParameterValue2, six.string_types):
                str += ' articulationParameterValue2="'+self.__articulationParameterValue2+'"'
            else:
                str += ' articulationParameterValue2="'+self.__articulationParameterValue2[0]+'"'
        if self.__articulationParameterValue3 is not None:
            if isinstance(self.__articulationParameterValue3, six.string_types):
                str += ' articulationParameterValue3="'+self.__articulationParameterValue3+'"'
            else:
                str += ' articulationParameterValue3="'+self.__articulationParameterValue3[0]+'"'
        if self.__articulationParameterValue4 is not None:
            if isinstance(self.__articulationParameterValue4, six.string_types):
                str += ' articulationParameterValue4="'+self.__articulationParameterValue4+'"'
            else:
                str += ' articulationParameterValue4="'+self.__articulationParameterValue4[0]+'"'
        if self.__articulationParameterValue5 is not None:
            if isinstance(self.__articulationParameterValue5, six.string_types):
                str += ' articulationParameterValue5="'+self.__articulationParameterValue5+'"'
            else:
                str += ' articulationParameterValue5="'+self.__articulationParameterValue5[0]+'"'
        if self.__articulationParameterValue6 is not None:
            if isinstance(self.__articulationParameterValue6, six.string_types):
                str += ' articulationParameterValue6="'+self.__articulationParameterValue6+'"'
            else:
                str += ' articulationParameterValue6="'+self.__articulationParameterValue6[0]+'"'
        if self.__articulationParameterValue7 is not None:
            if isinstance(self.__articulationParameterValue7, six.string_types):
                str += ' articulationParameterValue7="'+self.__articulationParameterValue7+'"'
            else:
                str += ' articulationParameterValue7="'+self.__articulationParameterValue7[0]+'"'
        if self.__siteID is not None:
            if isinstance(self.__siteID, six.string_types):
                str += ' siteID="'+self.__siteID+'"'
            else:
                str += ' siteID="'+self.__siteID[0]+'"'
        if self.__timestamp is not None:
            if isinstance(self.__timestamp, six.string_types):
                str += ' timestamp="'+self.__timestamp+'"'
            else:
                str += ' timestamp="'+self.__timestamp[0]+'"'
        if self.__translation is not None:
            if isinstance(self.__translation, six.string_types):
                str += ' translation="'+self.__translation+'"'
            else:
                str += ' translation="'+self.__translation[0]+'"'
        if self.__warhead is not None:
            if isinstance(self.__warhead, six.string_types):
                str += ' warhead="'+self.__warhead+'"'
            else:
                str += ' warhead="'+self.__warhead[0]+'"'
        if self.__writeInterval is not None:
            if isinstance(self.__writeInterval, six.string_types):
                str += ' writeInterval="'+self.__writeInterval+'"'
            else:
                str += ' writeInterval="'+self.__writeInterval[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '</EspduTransform>'
        return str


class ExplosionEmitter(X3DParticleEmitterNode):
    def __init__(self, **kwargs):
        super(ExplosionEmitter, self).__init__(**kwargs)
        mass  = kwargs.pop("mass", 0)
        if mass == None or mass  <  0:
            return None
        self.__mass = mass
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        position  = kwargs.pop("position", [0, 0, 0])
        self.__position = position
        speed  = kwargs.pop("speed", 0)
        if speed == None or speed  <  0:
            return None
        self.__speed = speed
        surfaceArea  = kwargs.pop("surfaceArea", 0)
        if surfaceArea == None or surfaceArea  <  0:
            return None
        self.__surfaceArea = surfaceArea
        variation  = kwargs.pop("variation", 0.25)
        if variation == None or variation  <  0:
            return None
        self.__variation = variation
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def mass(self):
        return self.__mass
    @mass.setter
    def mass(self, value = 0):
        if value == None or value  <  0:
            return None
        self.__mass = [value]
    def setMass(self, mass = 0):
        if mass == None or mass  <  0:
            return None
        self.__mass = [mass]
        return self
    def addMass(self, mass = 0):
        if mass == None or mass  <  0:
            return None
        if self.__mass == None:            self.__mass =  []
        self.__mass +=  [mass]
        return self
    def removeMass(self, mass):
        self.__mass = [x for x in self.__mass if x not in mass]
        return self.__mass
    def getMass(self, mass = 0):
        return self.__mass
    def mass_changed(self, mass = 0):
        return self.__mass
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def position(self):
        return self.__position
    @position.setter
    def position(self, value = [0, 0, 0]):
        self.__position = [value]
    def setPosition(self, position = [0, 0, 0]):
        self.__position = [position]
        return self
    def addPosition(self, position = [0, 0, 0]):
        if self.__position == None:            self.__position =  []
        self.__position +=  [position]
        return self
    def removePosition(self, position):
        self.__position = [x for x in self.__position if x not in position]
        return self.__position
    def getPosition(self, position = [0, 0, 0]):
        return self.__position
    def position_changed(self, position = [0, 0, 0]):
        return self.__position
    @property
    def speed(self):
        return self.__speed
    @speed.setter
    def speed(self, value = 0):
        if value == None or value  <  0:
            return None
        self.__speed = [value]
    def setSpeed(self, speed = 0):
        if speed == None or speed  <  0:
            return None
        self.__speed = [speed]
        return self
    def addSpeed(self, speed = 0):
        if speed == None or speed  <  0:
            return None
        if self.__speed == None:            self.__speed =  []
        self.__speed +=  [speed]
        return self
    def removeSpeed(self, speed):
        self.__speed = [x for x in self.__speed if x not in speed]
        return self.__speed
    def getSpeed(self, speed = 0):
        return self.__speed
    def speed_changed(self, speed = 0):
        return self.__speed
    @property
    def variation(self):
        return self.__variation
    @variation.setter
    def variation(self, value = 0.25):
        if value == None or value  <  0:
            return None
        self.__variation = [value]
    def setVariation(self, variation = 0.25):
        if variation == None or variation  <  0:
            return None
        self.__variation = [variation]
        return self
    def addVariation(self, variation = 0.25):
        if variation == None or variation  <  0:
            return None
        if self.__variation == None:            self.__variation =  []
        self.__variation +=  [variation]
        return self
    def removeVariation(self, variation):
        self.__variation = [x for x in self.__variation if x not in variation]
        return self.__variation
    def getVariation(self, variation = 0.25):
        return self.__variation
    def variation_changed(self, variation = 0.25):
        return self.__variation
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ExplosionEmitter'
        if self.__mass is not None:
            if isinstance(self.__mass, six.string_types):
                str += ' mass="'+self.__mass+'"'
            else:
                str += ' mass="'+self.__mass[0]+'"'
        if self.__position is not None:
            if isinstance(self.__position, six.string_types):
                str += ' position="'+self.__position+'"'
            else:
                str += ' position="'+self.__position[0]+'"'
        if self.__speed is not None:
            if isinstance(self.__speed, six.string_types):
                str += ' speed="'+self.__speed+'"'
            else:
                str += ' speed="'+self.__speed[0]+'"'
        if self.__surfaceArea is not None:
            if isinstance(self.__surfaceArea, six.string_types):
                str += ' surfaceArea="'+self.__surfaceArea+'"'
            else:
                str += ' surfaceArea="'+self.__surfaceArea[0]+'"'
        if self.__variation is not None:
            if isinstance(self.__variation, six.string_types):
                str += ' variation="'+self.__variation+'"'
            else:
                str += ' variation="'+self.__variation[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</ExplosionEmitter>'
        return str


class Extrusion(X3DGeometryNode):
    def __init__(self, **kwargs):
        super(Extrusion, self).__init__(**kwargs)
        beginCap  = kwargs.pop("beginCap", True)
        self.__beginCap = beginCap
        ccw  = kwargs.pop("ccw", True)
        self.__ccw = ccw
        convex  = kwargs.pop("convex", True)
        self.__convex = convex
        creaseAngle  = kwargs.pop("creaseAngle", 0.0)
        if creaseAngle == None or creaseAngle  <  0:
            return None
        self.__creaseAngle = creaseAngle
        crossSection  = kwargs.pop("crossSection", [1, 1, 1, -1, -1, -1, -1, 1, 1, 1])
        self.__crossSection = crossSection
        endCap  = kwargs.pop("endCap", True)
        self.__endCap = endCap
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        orientation  = kwargs.pop("orientation", [0, 0, 1, 0])
        self.__orientation = orientation
        scale  = kwargs.pop("scale", [1, 1])
        self.__scale = scale
        crossSection  = kwargs.pop("crossSection", None)
        self.__crossSection = crossSection
        orientation  = kwargs.pop("orientation", None)
        self.__orientation = orientation
        scale  = kwargs.pop("scale", None)
        self.__scale = scale
        spine  = kwargs.pop("spine", None)
        self.__spine = spine
        solid  = kwargs.pop("solid", True)
        self.__solid = solid
        spine  = kwargs.pop("spine", [0, 0, 0, 0, 1, 0])
        self.__spine = spine
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def orientation(self):
        return self.__orientation
    @orientation.setter
    def orientation(self, value = [0, 0, 1, 0]):
        self.__orientation = [value]
    def setOrientation(self, orientation = [0, 0, 1, 0]):
        self.__orientation = [orientation]
        return self
    def addOrientation(self, orientation = [0, 0, 1, 0]):
        if self.__orientation == None:            self.__orientation =  []
        self.__orientation +=  [orientation]
        return self
    def removeOrientation(self, orientation):
        self.__orientation = [x for x in self.__orientation if x not in orientation]
        return self.__orientation
    def getOrientation(self, orientation = [0, 0, 1, 0]):
        return self.__orientation
    def orientation_changed(self, orientation = [0, 0, 1, 0]):
        return self.__orientation
    @property
    def scale(self):
        return self.__scale
    @scale.setter
    def scale(self, value = [1, 1]):
        self.__scale = [value]
    def setScale(self, scale = [1, 1]):
        self.__scale = [scale]
        return self
    def addScale(self, scale = [1, 1]):
        if self.__scale == None:            self.__scale =  []
        self.__scale +=  [scale]
        return self
    def removeScale(self, scale):
        self.__scale = [x for x in self.__scale if x not in scale]
        return self.__scale
    def getScale(self, scale = [1, 1]):
        return self.__scale
    def scale_changed(self, scale = [1, 1]):
        return self.__scale
    @property
    def crossSection(self):
        return self.__crossSection
    @crossSection.setter
    def crossSection(self, value = None):
        self.__crossSection = [value]
    def set_crossSection(self, crossSection = None):
        self.__crossSection = [crossSection]
        return self
    @property
    def orientation(self):
        return self.__orientation
    @orientation.setter
    def orientation(self, value = None):
        self.__orientation = [value]
    def set_orientation(self, orientation = None):
        self.__orientation = [orientation]
        return self
    @property
    def scale(self):
        return self.__scale
    @scale.setter
    def scale(self, value = None):
        self.__scale = [value]
    def set_scale(self, scale = None):
        self.__scale = [scale]
        return self
    @property
    def spine(self):
        return self.__spine
    @spine.setter
    def spine(self, value = None):
        self.__spine = [value]
    def set_spine(self, spine = None):
        self.__spine = [spine]
        return self
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Extrusion'
        if self.__beginCap is not None:
            if isinstance(self.__beginCap, six.string_types):
                str += ' beginCap="'+self.__beginCap+'"'
            else:
                str += ' beginCap="'+self.__beginCap[0]+'"'
        if self.__ccw is not None:
            if isinstance(self.__ccw, six.string_types):
                str += ' ccw="'+self.__ccw+'"'
            else:
                str += ' ccw="'+self.__ccw[0]+'"'
        if self.__convex is not None:
            if isinstance(self.__convex, six.string_types):
                str += ' convex="'+self.__convex+'"'
            else:
                str += ' convex="'+self.__convex[0]+'"'
        if self.__creaseAngle is not None:
            if isinstance(self.__creaseAngle, six.string_types):
                str += ' creaseAngle="'+self.__creaseAngle+'"'
            else:
                str += ' creaseAngle="'+self.__creaseAngle[0]+'"'
        if self.__crossSection is not None:
            if isinstance(self.__crossSection, six.string_types):
                str += ' crossSection="'+self.__crossSection+'"'
            else:
                str += ' crossSection="'+self.__crossSection[0]+'"'
        if self.__endCap is not None:
            if isinstance(self.__endCap, six.string_types):
                str += ' endCap="'+self.__endCap+'"'
            else:
                str += ' endCap="'+self.__endCap[0]+'"'
        if self.__orientation is not None:
            if isinstance(self.__orientation, six.string_types):
                str += ' orientation="'+self.__orientation+'"'
            else:
                str += ' orientation="'+self.__orientation[0]+'"'
        if self.__scale is not None:
            if isinstance(self.__scale, six.string_types):
                str += ' scale="'+self.__scale+'"'
            else:
                str += ' scale="'+self.__scale[0]+'"'
        if self.__crossSection is not None:
            if isinstance(self.__crossSection, six.string_types):
                str += ' crossSection="'+self.__crossSection+'"'
            else:
                str += ' crossSection="'+self.__crossSection[0]+'"'
        if self.__orientation is not None:
            if isinstance(self.__orientation, six.string_types):
                str += ' orientation="'+self.__orientation+'"'
            else:
                str += ' orientation="'+self.__orientation[0]+'"'
        if self.__scale is not None:
            if isinstance(self.__scale, six.string_types):
                str += ' scale="'+self.__scale+'"'
            else:
                str += ' scale="'+self.__scale[0]+'"'
        if self.__spine is not None:
            if isinstance(self.__spine, six.string_types):
                str += ' spine="'+self.__spine+'"'
            else:
                str += ' spine="'+self.__spine[0]+'"'
        if self.__solid is not None:
            if isinstance(self.__solid, six.string_types):
                str += ' solid="'+self.__solid+'"'
            else:
                str += ' solid="'+self.__solid[0]+'"'
        if self.__spine is not None:
            if isinstance(self.__spine, six.string_types):
                str += ' spine="'+self.__spine+'"'
            else:
                str += ' spine="'+self.__spine[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</Extrusion>'
        return str


class FillProperties(X3DAppearanceChildNode):
    def __init__(self, **kwargs):
        super(FillProperties, self).__init__(**kwargs)
        filled  = kwargs.pop("filled", True)
        self.__filled = filled
        hatchColor  = kwargs.pop("hatchColor", [1, 1, 1])
        if hatchColor == None or len(hatchColor) <= 0 or min(hatchColor)  <  0:
            return None
        if hatchColor == None or len(hatchColor) <= 0 or max(hatchColor)  >  1:
            return None
        self.__hatchColor = hatchColor
        hatched  = kwargs.pop("hatched", True)
        self.__hatched = hatched
        hatchStyle  = kwargs.pop("hatchStyle", 1)
        self.__hatchStyle = hatchStyle
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def filled(self):
        return self.__filled
    @filled.setter
    def filled(self, value = True):
        self.__filled = [value]
    def setFilled(self, filled = True):
        self.__filled = [filled]
        return self
    def addFilled(self, filled = True):
        if self.__filled == None:            self.__filled =  []
        self.__filled +=  [filled]
        return self
    def removeFilled(self, filled):
        self.__filled = [x for x in self.__filled if x not in filled]
        return self.__filled
    def isFilled(self, filled = True):
        return self.__filled
    @property
    def hatchColor(self):
        return self.__hatchColor
    @hatchColor.setter
    def hatchColor(self, value = [1, 1, 1]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__hatchColor = [value]
    def setHatchColor(self, hatchColor = [1, 1, 1]):
        if hatchColor == None or len(hatchColor) <= 0 or min(hatchColor)  <  0:
            return None
        if hatchColor == None or len(hatchColor) <= 0 or max(hatchColor)  >  1:
            return None
        self.__hatchColor = [hatchColor]
        return self
    def addHatchColor(self, hatchColor = [1, 1, 1]):
        if hatchColor == None or len(hatchColor) <= 0 or min(hatchColor)  <  0:
            return None
        if hatchColor == None or len(hatchColor) <= 0 or max(hatchColor)  >  1:
            return None
        if self.__hatchColor == None:            self.__hatchColor =  []
        self.__hatchColor +=  [hatchColor]
        return self
    def removeHatchColor(self, hatchColor):
        self.__hatchColor = [x for x in self.__hatchColor if x not in hatchColor]
        return self.__hatchColor
    def getHatchColor(self, hatchColor = [1, 1, 1]):
        return self.__hatchColor
    def hatchColor_changed(self, hatchColor = [1, 1, 1]):
        return self.__hatchColor
    @property
    def hatched(self):
        return self.__hatched
    @hatched.setter
    def hatched(self, value = True):
        self.__hatched = [value]
    def setHatched(self, hatched = True):
        self.__hatched = [hatched]
        return self
    def addHatched(self, hatched = True):
        if self.__hatched == None:            self.__hatched =  []
        self.__hatched +=  [hatched]
        return self
    def removeHatched(self, hatched):
        self.__hatched = [x for x in self.__hatched if x not in hatched]
        return self.__hatched
    def isHatched(self, hatched = True):
        return self.__hatched
    @property
    def hatchStyle(self):
        return self.__hatchStyle
    @hatchStyle.setter
    def hatchStyle(self, value = 1):
        self.__hatchStyle = [value]
    def setHatchStyle(self, hatchStyle = 1):
        self.__hatchStyle = [hatchStyle]
        return self
    def addHatchStyle(self, hatchStyle = 1):
        if self.__hatchStyle == None:            self.__hatchStyle =  []
        self.__hatchStyle +=  [hatchStyle]
        return self
    def removeHatchStyle(self, hatchStyle):
        self.__hatchStyle = [x for x in self.__hatchStyle if x not in hatchStyle]
        return self.__hatchStyle
    def getHatchStyle(self, hatchStyle = 1):
        return self.__hatchStyle
    def hatchStyle_changed(self, hatchStyle = 1):
        return self.__hatchStyle
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<FillProperties'
        if self.__filled is not None:
            if isinstance(self.__filled, six.string_types):
                str += ' filled="'+self.__filled+'"'
            else:
                str += ' filled="'+self.__filled[0]+'"'
        if self.__hatchColor is not None:
            if isinstance(self.__hatchColor, six.string_types):
                str += ' hatchColor="'+self.__hatchColor+'"'
            else:
                str += ' hatchColor="'+self.__hatchColor[0]+'"'
        if self.__hatched is not None:
            if isinstance(self.__hatched, six.string_types):
                str += ' hatched="'+self.__hatched+'"'
            else:
                str += ' hatched="'+self.__hatched[0]+'"'
        if self.__hatchStyle is not None:
            if isinstance(self.__hatchStyle, six.string_types):
                str += ' hatchStyle="'+self.__hatchStyle+'"'
            else:
                str += ' hatchStyle="'+self.__hatchStyle[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</FillProperties>'
        return str


class FloatVertexAttribute(X3DVertexAttributeNode):
    def __init__(self, **kwargs):
        super(FloatVertexAttribute, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        name  = kwargs.pop("name", None)
        self.__name = name
        numComponents  = kwargs.pop("numComponents", 4)
        if numComponents == None or numComponents  <  1:
            return None
        if numComponents == None or numComponents  >  4:
            return None
        self.__numComponents = numComponents
        value  = kwargs.pop("value", None)
        self.__value = value
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        self.__name = [value]
    def setName(self, name = None):
        self.__name = [name]
        return self
    def addName(self, name = None):
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def value(self):
        return self.__value
    @value.setter
    def value(self, value = None):
        self.__value = [value]
    def setValue(self, value = None):
        self.__value = [value]
        return self
    def addValue(self, value = None):
        if self.__value == None:            self.__value =  []
        self.__value +=  [value]
        return self
    def removeValue(self, value):
        self.__value = [x for x in self.__value if x not in value]
        return self.__value
    def getValue(self, value = None):
        return self.__value
    def value_changed(self, value = None):
        return self.__value
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<FloatVertexAttribute'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        if self.__numComponents is not None:
            if isinstance(self.__numComponents, six.string_types):
                str += ' numComponents="'+self.__numComponents+'"'
            else:
                str += ' numComponents="'+self.__numComponents[0]+'"'
        if self.__value is not None:
            if isinstance(self.__value, six.string_types):
                str += ' value="'+self.__value+'"'
            else:
                str += ' value="'+self.__value[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</FloatVertexAttribute>'
        return str


class Fog(X3DFogObject, X3DBindableNode):
    def __init__(self, **kwargs):
        super(Fog, self).__init__(**kwargs)
        bindTime  = kwargs.pop("bindTime", None)
        self.__bindTime = bindTime
        color  = kwargs.pop("color", [1, 1, 1])
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        self.__color = color
        fogType  = kwargs.pop("fogType", "LINEAR")
        if 'LINEAR' == fogType:
            pass
        elif 'EXPONENTIAL' == fogType:
            pass
        else:
            return None
        self.__fogType = fogType
        Bound  = kwargs.pop("Bound", None)
        self.__Bound = Bound
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        bind  = kwargs.pop("bind", None)
        self.__bind = bind
        visibilityRange  = kwargs.pop("visibilityRange", 0)
        if visibilityRange == None or visibilityRange  <  0:
            return None
        self.__visibilityRange = visibilityRange
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def removeBindTime(self, bindTime):
        self.__bindTime = [x for x in self.__bindTime if x not in bindTime]
        return self.__bindTime
    def getBindTime(self, bindTime = None):
        return self.__bindTime
    def bindTime_changed(self, bindTime = None):
        return self.__bindTime
    @property
    def color(self):
        return self.__color
    @color.setter
    def color(self, value = [1, 1, 1]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__color = [value]
    def setColor(self, color = [1, 1, 1]):
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        self.__color = [color]
        return self
    def addColor(self, color = [1, 1, 1]):
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        if self.__color == None:            self.__color =  []
        self.__color +=  [color]
        return self
    def removeColor(self, color):
        self.__color = [x for x in self.__color if x not in color]
        return self.__color
    def getColor(self, color = [1, 1, 1]):
        return self.__color
    def color_changed(self, color = [1, 1, 1]):
        return self.__color
    @property
    def fogType(self):
        return self.__fogType
    @fogType.setter
    def fogType(self, value = "LINEAR"):
        if 'LINEAR' == value:
            pass
        elif 'EXPONENTIAL' == value:
            pass
        else:
            return None
        self.__fogType = [value]
    def setFogType(self, fogType = "LINEAR"):
        if 'LINEAR' == fogType:
            pass
        elif 'EXPONENTIAL' == fogType:
            pass
        else:
            return None
        self.__fogType = [fogType]
        return self
    def addFogType(self, fogType = "LINEAR"):
        if 'LINEAR' == fogType:
            pass
        elif 'EXPONENTIAL' == fogType:
            pass
        else:
            return None
        if self.__fogType == None:            self.__fogType =  []
        self.__fogType +=  [fogType]
        return self
    def removeFogType(self, fogType):
        self.__fogType = [x for x in self.__fogType if x not in fogType]
        return self.__fogType
    def getFogType(self, fogType = "LINEAR"):
        return self.__fogType
    def fogType_changed(self, fogType = "LINEAR"):
        return self.__fogType
    def isBound(self, Bound = None):
        return self.__Bound
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def bind(self):
        return self.__bind
    @bind.setter
    def bind(self, value = None):
        self.__bind = [value]
    def set_bind(self, bind = None):
        self.__bind = [bind]
        return self
    @property
    def visibilityRange(self):
        return self.__visibilityRange
    @visibilityRange.setter
    def visibilityRange(self, value = 0):
        if value == None or value  <  0:
            return None
        self.__visibilityRange = [value]
    def setVisibilityRange(self, visibilityRange = 0):
        if visibilityRange == None or visibilityRange  <  0:
            return None
        self.__visibilityRange = [visibilityRange]
        return self
    def addVisibilityRange(self, visibilityRange = 0):
        if visibilityRange == None or visibilityRange  <  0:
            return None
        if self.__visibilityRange == None:            self.__visibilityRange =  []
        self.__visibilityRange +=  [visibilityRange]
        return self
    def removeVisibilityRange(self, visibilityRange):
        self.__visibilityRange = [x for x in self.__visibilityRange if x not in visibilityRange]
        return self.__visibilityRange
    def getVisibilityRange(self, visibilityRange = 0):
        return self.__visibilityRange
    def visibilityRange_changed(self, visibilityRange = 0):
        return self.__visibilityRange
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Fog'
        if self.__bindTime is not None:
            if isinstance(self.__bindTime, six.string_types):
                str += ' bindTime="'+self.__bindTime+'"'
            else:
                str += ' bindTime="'+self.__bindTime[0]+'"'
        if self.__color is not None:
            if isinstance(self.__color, six.string_types):
                str += ' color="'+self.__color+'"'
            else:
                str += ' color="'+self.__color[0]+'"'
        if self.__fogType is not None:
            if isinstance(self.__fogType, six.string_types):
                str += ' fogType="'+self.__fogType+'"'
            else:
                str += ' fogType="'+self.__fogType[0]+'"'
        if self.__Bound is not None:
            if isinstance(self.__Bound, six.string_types):
                str += ' Bound="'+self.__Bound+'"'
            else:
                str += ' Bound="'+self.__Bound[0]+'"'
        if self.__bind is not None:
            if isinstance(self.__bind, six.string_types):
                str += ' bind="'+self.__bind+'"'
            else:
                str += ' bind="'+self.__bind[0]+'"'
        if self.__visibilityRange is not None:
            if isinstance(self.__visibilityRange, six.string_types):
                str += ' visibilityRange="'+self.__visibilityRange+'"'
            else:
                str += ' visibilityRange="'+self.__visibilityRange[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</Fog>'
        return str


class FogCoordinate(X3DGeometricPropertyNode):
    def __init__(self, **kwargs):
        super(FogCoordinate, self).__init__(**kwargs)
        depth  = kwargs.pop("depth", None)
        if depth == None or len(depth) <= 0 or min(depth)  <  0:
            return None
        if depth == None or len(depth) <= 0 or max(depth)  >  1:
            return None
        self.__depth = depth
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def depth(self):
        return self.__depth
    @depth.setter
    def depth(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__depth = [value]
    def setDepth(self, depth = None):
        if depth == None or len(depth) <= 0 or min(depth)  <  0:
            return None
        if depth == None or len(depth) <= 0 or max(depth)  >  1:
            return None
        self.__depth = [depth]
        return self
    def addDepth(self, depth = None):
        if depth == None or len(depth) <= 0 or min(depth)  <  0:
            return None
        if depth == None or len(depth) <= 0 or max(depth)  >  1:
            return None
        if self.__depth == None:            self.__depth =  []
        self.__depth +=  [depth]
        return self
    def removeDepth(self, depth):
        self.__depth = [x for x in self.__depth if x not in depth]
        return self.__depth
    def getDepth(self, depth = None):
        return self.__depth
    def depth_changed(self, depth = None):
        return self.__depth
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<FogCoordinate'
        if self.__depth is not None:
            if isinstance(self.__depth, six.string_types):
                str += ' depth="'+self.__depth+'"'
            else:
                str += ' depth="'+self.__depth[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</FogCoordinate>'
        return str


class FontStyle(X3DFontStyleNode):
    def __init__(self, **kwargs):
        super(FontStyle, self).__init__(**kwargs)
        family  = kwargs.pop("family", ["SERIF"])
        self.__family = family
        horizontal  = kwargs.pop("horizontal", True)
        self.__horizontal = horizontal
        justify  = kwargs.pop("justify", ["BEGIN"])
        if '"MIDDLE"' == justify:
            pass
        elif '"MIDDLE" "BEGIN"' == justify:
            pass
        elif '"MIDDLE" "END"' == justify:
            pass
        elif '"MIDDLE" "FIRST"' == justify:
            pass
        elif '"MIDDLE" "MIDDLE"' == justify:
            pass
        elif '"BEGIN"' == justify:
            pass
        elif '"BEGIN" "BEGIN"' == justify:
            pass
        elif '"BEGIN" "END"' == justify:
            pass
        elif '"BEGIN" "FIRST"' == justify:
            pass
        elif '"BEGIN" "MIDDLE"' == justify:
            pass
        elif '"END"' == justify:
            pass
        elif '"END" "BEGIN"' == justify:
            pass
        elif '"END" "END"' == justify:
            pass
        elif '"END" "FIRST"' == justify:
            pass
        elif '"END" "MIDDLE"' == justify:
            pass
        elif '"FIRST"' == justify:
            pass
        elif '"FIRST" "BEGIN"' == justify:
            pass
        elif '"FIRST" "END"' == justify:
            pass
        elif '"FIRST" "FIRST"' == justify:
            pass
        elif '"FIRST" "MIDDLE"' == justify:
            pass
        else:
            return None
        self.__justify = justify
        language  = kwargs.pop("language", None)
        self.__language = language
        leftToRight  = kwargs.pop("leftToRight", True)
        self.__leftToRight = leftToRight
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        size  = kwargs.pop("size", 1.0)
        if size == None or size  <=  0:
            return None
        self.__size = size
        spacing  = kwargs.pop("spacing", 1.0)
        if spacing == None or spacing  <  0:
            return None
        self.__spacing = spacing
        style  = kwargs.pop("style", "PLAIN")
        if 'PLAIN' == style:
            pass
        elif 'BOLD' == style:
            pass
        elif 'ITALIC' == style:
            pass
        elif 'BOLDITALIC' == style:
            pass
        else:
            return None
        self.__style = style
        topToBottom  = kwargs.pop("topToBottom", True)
        self.__topToBottom = topToBottom
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<FontStyle'
        if self.__family is not None:
            if isinstance(self.__family, six.string_types):
                str += ' family="'+self.__family+'"'
            else:
                str += ' family="'+self.__family[0]+'"'
        if self.__horizontal is not None:
            if isinstance(self.__horizontal, six.string_types):
                str += ' horizontal="'+self.__horizontal+'"'
            else:
                str += ' horizontal="'+self.__horizontal[0]+'"'
        if self.__justify is not None:
            if isinstance(self.__justify, six.string_types):
                str += ' justify="'+self.__justify+'"'
            else:
                str += ' justify="'+self.__justify[0]+'"'
        if self.__language is not None:
            if isinstance(self.__language, six.string_types):
                str += ' language="'+self.__language+'"'
            else:
                str += ' language="'+self.__language[0]+'"'
        if self.__leftToRight is not None:
            if isinstance(self.__leftToRight, six.string_types):
                str += ' leftToRight="'+self.__leftToRight+'"'
            else:
                str += ' leftToRight="'+self.__leftToRight[0]+'"'
        if self.__size is not None:
            if isinstance(self.__size, six.string_types):
                str += ' size="'+self.__size+'"'
            else:
                str += ' size="'+self.__size[0]+'"'
        if self.__spacing is not None:
            if isinstance(self.__spacing, six.string_types):
                str += ' spacing="'+self.__spacing+'"'
            else:
                str += ' spacing="'+self.__spacing[0]+'"'
        if self.__style is not None:
            if isinstance(self.__style, six.string_types):
                str += ' style="'+self.__style+'"'
            else:
                str += ' style="'+self.__style[0]+'"'
        if self.__topToBottom is not None:
            if isinstance(self.__topToBottom, six.string_types):
                str += ' topToBottom="'+self.__topToBottom+'"'
            else:
                str += ' topToBottom="'+self.__topToBottom[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</FontStyle>'
        return str


class ForcePhysicsModel(X3DParticlePhysicsModelNode):
    def __init__(self, **kwargs):
        super(ForcePhysicsModel, self).__init__(**kwargs)
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        force  = kwargs.pop("force", [0, -9.8, 0])
        self.__force = force
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def force(self):
        return self.__force
    @force.setter
    def force(self, value = [0, -9.8, 0]):
        self.__force = [value]
    def setForce(self, force = [0, -9.8, 0]):
        self.__force = [force]
        return self
    def addForce(self, force = [0, -9.8, 0]):
        if self.__force == None:            self.__force =  []
        self.__force +=  [force]
        return self
    def removeForce(self, force):
        self.__force = [x for x in self.__force if x not in force]
        return self.__force
    def getForce(self, force = [0, -9.8, 0]):
        return self.__force
    def force_changed(self, force = [0, -9.8, 0]):
        return self.__force
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ForcePhysicsModel'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__force is not None:
            if isinstance(self.__force, six.string_types):
                str += ' force="'+self.__force+'"'
            else:
                str += ' force="'+self.__force[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</ForcePhysicsModel>'
        return str


class GeneratedCubeMapTexture(X3DEnvironmentTextureNode):
    def __init__(self, **kwargs):
        super(GeneratedCubeMapTexture, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        size  = kwargs.pop("size", 128)
        if size == None or size  <=  0:
            return None
        self.__size = size
        textureProperties  = kwargs.pop("textureProperties", None)
        self.__textureProperties = textureProperties
        update  = kwargs.pop("update", "NONE")
        if 'NONE' == update:
            pass
        elif 'NEXT_FRAME_ONLY' == update:
            pass
        elif 'ALWAYS' == update:
            pass
        else:
            return None
        self.__update = update
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def update(self):
        return self.__update
    @update.setter
    def update(self, value = "NONE"):
        if 'NONE' == value:
            pass
        elif 'NEXT_FRAME_ONLY' == value:
            pass
        elif 'ALWAYS' == value:
            pass
        else:
            return None
        self.__update = [value]
    def setUpdate(self, update = "NONE"):
        if 'NONE' == update:
            pass
        elif 'NEXT_FRAME_ONLY' == update:
            pass
        elif 'ALWAYS' == update:
            pass
        else:
            return None
        self.__update = [update]
        return self
    def addUpdate(self, update = "NONE"):
        if 'NONE' == update:
            pass
        elif 'NEXT_FRAME_ONLY' == update:
            pass
        elif 'ALWAYS' == update:
            pass
        else:
            return None
        if self.__update == None:            self.__update =  []
        self.__update +=  [update]
        return self
    def removeUpdate(self, update):
        self.__update = [x for x in self.__update if x not in update]
        return self.__update
    def getUpdate(self, update = "NONE"):
        return self.__update
    def update_changed(self, update = "NONE"):
        return self.__update
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<GeneratedCubeMapTexture'
        if self.__size is not None:
            if isinstance(self.__size, six.string_types):
                str += ' size="'+self.__size+'"'
            else:
                str += ' size="'+self.__size[0]+'"'
        if self.__update is not None:
            if isinstance(self.__update, six.string_types):
                str += ' update="'+self.__update+'"'
            else:
                str += ' update="'+self.__update[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<textureProperties'
        if self.__textureProperties is not None:
           for s in self.__textureProperties:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__textureProperties is not None:
           for s in self.__textureProperties:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</textureProperties>'
        str += '</GeneratedCubeMapTexture>'
        return str


class GeoCoordinate(X3DCoordinateNode):
    def __init__(self, **kwargs):
        super(GeoCoordinate, self).__init__(**kwargs)
        geoOrigin  = kwargs.pop("geoOrigin", None)
        self.__geoOrigin = geoOrigin
        geoSystem  = kwargs.pop("geoSystem", ["GD", "WE"])
        self.__geoSystem = geoSystem
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        point  = kwargs.pop("point", None)
        self.__point = point
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def point(self):
        return self.__point
    @point.setter
    def point(self, value = None):
        self.__point = [value]
    def setPoint(self, point = None):
        self.__point = [point]
        return self
    def addPoint(self, point = None):
        if self.__point == None:            self.__point =  []
        self.__point +=  [point]
        return self
    def removePoint(self, point):
        self.__point = [x for x in self.__point if x not in point]
        return self.__point
    def getPoint(self, point = None):
        return self.__point
    def point_changed(self, point = None):
        return self.__point
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<GeoCoordinate'
        if self.__geoSystem is not None:
            if isinstance(self.__geoSystem, six.string_types):
                str += ' geoSystem="'+self.__geoSystem+'"'
            else:
                str += ' geoSystem="'+self.__geoSystem[0]+'"'
        if self.__point is not None:
            if isinstance(self.__point, six.string_types):
                str += ' point="'+self.__point+'"'
            else:
                str += ' point="'+self.__point[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<geoOrigin'
        if self.__geoOrigin is not None:
           for s in self.__geoOrigin:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__geoOrigin is not None:
           for s in self.__geoOrigin:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</geoOrigin>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</GeoCoordinate>'
        return str


class GeoElevationGrid(X3DGeometryNode):
    def __init__(self, **kwargs):
        super(GeoElevationGrid, self).__init__(**kwargs)
        ccw  = kwargs.pop("ccw", True)
        self.__ccw = ccw
        color  = kwargs.pop("color", None)
        self.__color = color
        colorPerVertex  = kwargs.pop("colorPerVertex", True)
        self.__colorPerVertex = colorPerVertex
        creaseAngle  = kwargs.pop("creaseAngle", 0)
        if creaseAngle == None or creaseAngle  <  0:
            return None
        self.__creaseAngle = creaseAngle
        geoGridOrigin  = kwargs.pop("geoGridOrigin", [0, 0, 0])
        self.__geoGridOrigin = geoGridOrigin
        geoOrigin  = kwargs.pop("geoOrigin", None)
        self.__geoOrigin = geoOrigin
        geoSystem  = kwargs.pop("geoSystem", ["GD", "WE"])
        self.__geoSystem = geoSystem
        height  = kwargs.pop("height", [0, 0, 0, 0])
        self.__height = height
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        normal  = kwargs.pop("normal", None)
        self.__normal = normal
        normalPerVertex  = kwargs.pop("normalPerVertex", True)
        self.__normalPerVertex = normalPerVertex
        height  = kwargs.pop("height", None)
        self.__height = height
        solid  = kwargs.pop("solid", True)
        self.__solid = solid
        texCoord  = kwargs.pop("texCoord", None)
        self.__texCoord = texCoord
        xDimension  = kwargs.pop("xDimension", 2)
        if xDimension == None or xDimension  <  0:
            return None
        self.__xDimension = xDimension
        xSpacing  = kwargs.pop("xSpacing", 1.0)
        if xSpacing == None or xSpacing  <=  0:
            return None
        self.__xSpacing = xSpacing
        yScale  = kwargs.pop("yScale", 1)
        if yScale == None or yScale  <  0:
            return None
        self.__yScale = yScale
        zDimension  = kwargs.pop("zDimension", 2)
        if zDimension == None or zDimension  <  0:
            return None
        self.__zDimension = zDimension
        zSpacing  = kwargs.pop("zSpacing", 1.0)
        if zSpacing == None or zSpacing  <=  0:
            return None
        self.__zSpacing = zSpacing
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def color(self):
        return self.__color
    @color.setter
    def color(self, value = None):
        self.__color = [value]
    def setColor(self, color = None):
        self.__color = [color]
        return self
    def addColor(self, color = None):
        if self.__color == None:            self.__color =  []
        self.__color +=  [color]
        return self
    def removeColor(self, color):
        self.__color = [x for x in self.__color if x not in color]
        return self.__color
    def getColor(self, color = None):
        return self.__color
    def color_changed(self, color = None):
        return self.__color
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def normal(self):
        return self.__normal
    @normal.setter
    def normal(self, value = None):
        self.__normal = [value]
    def setNormal(self, normal = None):
        self.__normal = [normal]
        return self
    def addNormal(self, normal = None):
        if self.__normal == None:            self.__normal =  []
        self.__normal +=  [normal]
        return self
    def removeNormal(self, normal):
        self.__normal = [x for x in self.__normal if x not in normal]
        return self.__normal
    def getNormal(self, normal = None):
        return self.__normal
    def normal_changed(self, normal = None):
        return self.__normal
    @property
    def height(self):
        return self.__height
    @height.setter
    def height(self, value = None):
        self.__height = [value]
    def set_height(self, height = None):
        self.__height = [height]
        return self
    @property
    def texCoord(self):
        return self.__texCoord
    @texCoord.setter
    def texCoord(self, value = None):
        self.__texCoord = [value]
    def setTexCoord(self, texCoord = None):
        self.__texCoord = [texCoord]
        return self
    def addTexCoord(self, texCoord = None):
        if self.__texCoord == None:            self.__texCoord =  []
        self.__texCoord +=  [texCoord]
        return self
    def removeTexCoord(self, texCoord):
        self.__texCoord = [x for x in self.__texCoord if x not in texCoord]
        return self.__texCoord
    def getTexCoord(self, texCoord = None):
        return self.__texCoord
    def texCoord_changed(self, texCoord = None):
        return self.__texCoord
    @property
    def yScale(self):
        return self.__yScale
    @yScale.setter
    def yScale(self, value = 1):
        if value == None or value  <  0:
            return None
        self.__yScale = [value]
    def setYScale(self, yScale = 1):
        if yScale == None or yScale  <  0:
            return None
        self.__yScale = [yScale]
        return self
    def addYScale(self, yScale = 1):
        if yScale == None or yScale  <  0:
            return None
        if self.__yScale == None:            self.__yScale =  []
        self.__yScale +=  [yScale]
        return self
    def removeYScale(self, yScale):
        self.__yScale = [x for x in self.__yScale if x not in yScale]
        return self.__yScale
    def getYScale(self, yScale = 1):
        return self.__yScale
    def yScale_changed(self, yScale = 1):
        return self.__yScale
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<GeoElevationGrid'
        if self.__ccw is not None:
            if isinstance(self.__ccw, six.string_types):
                str += ' ccw="'+self.__ccw+'"'
            else:
                str += ' ccw="'+self.__ccw[0]+'"'
        if self.__colorPerVertex is not None:
            if isinstance(self.__colorPerVertex, six.string_types):
                str += ' colorPerVertex="'+self.__colorPerVertex+'"'
            else:
                str += ' colorPerVertex="'+self.__colorPerVertex[0]+'"'
        if self.__creaseAngle is not None:
            if isinstance(self.__creaseAngle, six.string_types):
                str += ' creaseAngle="'+self.__creaseAngle+'"'
            else:
                str += ' creaseAngle="'+self.__creaseAngle[0]+'"'
        if self.__geoGridOrigin is not None:
            if isinstance(self.__geoGridOrigin, six.string_types):
                str += ' geoGridOrigin="'+self.__geoGridOrigin+'"'
            else:
                str += ' geoGridOrigin="'+self.__geoGridOrigin[0]+'"'
        if self.__geoSystem is not None:
            if isinstance(self.__geoSystem, six.string_types):
                str += ' geoSystem="'+self.__geoSystem+'"'
            else:
                str += ' geoSystem="'+self.__geoSystem[0]+'"'
        if self.__height is not None:
            if isinstance(self.__height, six.string_types):
                str += ' height="'+self.__height+'"'
            else:
                str += ' height="'+self.__height[0]+'"'
        if self.__normalPerVertex is not None:
            if isinstance(self.__normalPerVertex, six.string_types):
                str += ' normalPerVertex="'+self.__normalPerVertex+'"'
            else:
                str += ' normalPerVertex="'+self.__normalPerVertex[0]+'"'
        if self.__height is not None:
            if isinstance(self.__height, six.string_types):
                str += ' height="'+self.__height+'"'
            else:
                str += ' height="'+self.__height[0]+'"'
        if self.__solid is not None:
            if isinstance(self.__solid, six.string_types):
                str += ' solid="'+self.__solid+'"'
            else:
                str += ' solid="'+self.__solid[0]+'"'
        if self.__xDimension is not None:
            if isinstance(self.__xDimension, six.string_types):
                str += ' xDimension="'+self.__xDimension+'"'
            else:
                str += ' xDimension="'+self.__xDimension[0]+'"'
        if self.__xSpacing is not None:
            if isinstance(self.__xSpacing, six.string_types):
                str += ' xSpacing="'+self.__xSpacing+'"'
            else:
                str += ' xSpacing="'+self.__xSpacing[0]+'"'
        if self.__yScale is not None:
            if isinstance(self.__yScale, six.string_types):
                str += ' yScale="'+self.__yScale+'"'
            else:
                str += ' yScale="'+self.__yScale[0]+'"'
        if self.__zDimension is not None:
            if isinstance(self.__zDimension, six.string_types):
                str += ' zDimension="'+self.__zDimension+'"'
            else:
                str += ' zDimension="'+self.__zDimension[0]+'"'
        if self.__zSpacing is not None:
            if isinstance(self.__zSpacing, six.string_types):
                str += ' zSpacing="'+self.__zSpacing+'"'
            else:
                str += ' zSpacing="'+self.__zSpacing[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<color'
        if self.__color is not None:
           for s in self.__color:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__color is not None:
           for s in self.__color:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</color>'
        str += '<geoOrigin'
        if self.__geoOrigin is not None:
           for s in self.__geoOrigin:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__geoOrigin is not None:
           for s in self.__geoOrigin:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</geoOrigin>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<normal'
        if self.__normal is not None:
           for s in self.__normal:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__normal is not None:
           for s in self.__normal:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</normal>'
        str += '<texCoord'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</texCoord>'
        str += '</GeoElevationGrid>'
        return str


class GeoLocation(X3DGroupingNode):
    def __init__(self, **kwargs):
        super(GeoLocation, self).__init__(**kwargs)
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        children  = kwargs.pop("children", None)
        self.__children = children
        geoCoords  = kwargs.pop("geoCoords", [0, 0, 0])
        self.__geoCoords = geoCoords
        geoOrigin  = kwargs.pop("geoOrigin", None)
        self.__geoOrigin = geoOrigin
        geoSystem  = kwargs.pop("geoSystem", ["GD", "WE"])
        self.__geoSystem = geoSystem
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    def addChildren(self, Children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [Children]
        return self
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    @property
    def geoCoords(self):
        return self.__geoCoords
    @geoCoords.setter
    def geoCoords(self, value = [0, 0, 0]):
        self.__geoCoords = [value]
    def setGeoCoords(self, geoCoords = [0, 0, 0]):
        self.__geoCoords = [geoCoords]
        return self
    def addGeoCoords(self, geoCoords = [0, 0, 0]):
        if self.__geoCoords == None:            self.__geoCoords =  []
        self.__geoCoords +=  [geoCoords]
        return self
    def removeGeoCoords(self, geoCoords):
        self.__geoCoords = [x for x in self.__geoCoords if x not in geoCoords]
        return self.__geoCoords
    def getGeoCoords(self, geoCoords = [0, 0, 0]):
        return self.__geoCoords
    def geoCoords_changed(self, geoCoords = [0, 0, 0]):
        return self.__geoCoords
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<GeoLocation'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__geoCoords is not None:
            if isinstance(self.__geoCoords, six.string_types):
                str += ' geoCoords="'+self.__geoCoords+'"'
            else:
                str += ' geoCoords="'+self.__geoCoords[0]+'"'
        if self.__geoSystem is not None:
            if isinstance(self.__geoSystem, six.string_types):
                str += ' geoSystem="'+self.__geoSystem+'"'
            else:
                str += ' geoSystem="'+self.__geoSystem[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '<geoOrigin'
        if self.__geoOrigin is not None:
           for s in self.__geoOrigin:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__geoOrigin is not None:
           for s in self.__geoOrigin:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</geoOrigin>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '</GeoLocation>'
        return str


class GeoLOD(X3DBoundedObject, X3DChildNode):
    def __init__(self, **kwargs):
        super(GeoLOD, self).__init__(**kwargs)
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        center  = kwargs.pop("center", [0, 0, 0])
        self.__center = center
        child1Url  = kwargs.pop("child1Url", None)
        self.__child1Url = child1Url
        child2Url  = kwargs.pop("child2Url", None)
        self.__child2Url = child2Url
        child3Url  = kwargs.pop("child3Url", None)
        self.__child3Url = child3Url
        child4Url  = kwargs.pop("child4Url", None)
        self.__child4Url = child4Url
        children  = kwargs.pop("children", None)
        self.__children = children
        geoOrigin  = kwargs.pop("geoOrigin", None)
        self.__geoOrigin = geoOrigin
        geoSystem  = kwargs.pop("geoSystem", ["GD", "WE"])
        self.__geoSystem = geoSystem
        level_changed  = kwargs.pop("level_changed", None)
        if level_changed == None or level_changed  <  0:
            return None
        if level_changed == None or level_changed  >  1:
            return None
        self.__level_changed = level_changed
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        range  = kwargs.pop("range", 10)
        if range == None or range  <  0:
            return None
        self.__range = range
        rootNode  = kwargs.pop("rootNode", None)
        self.__rootNode = rootNode
        rootUrl  = kwargs.pop("rootUrl", None)
        self.__rootUrl = rootUrl
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    def removelevel_changed(self, level_changed):
        self.__level_changed = [x for x in self.__level_changed if x not in level_changed]
        return self.__level_changed
    def getlevel_changed(self, level_changed = None):
        return self.__level_changed
    def level_changed_changed(self, level_changed = None):
        return self.__level_changed
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<GeoLOD'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__center is not None:
            if isinstance(self.__center, six.string_types):
                str += ' center="'+self.__center+'"'
            else:
                str += ' center="'+self.__center[0]+'"'
        if self.__child1Url is not None:
            if isinstance(self.__child1Url, six.string_types):
                str += ' child1Url="'+self.__child1Url+'"'
            else:
                str += ' child1Url="'+self.__child1Url[0]+'"'
        if self.__child2Url is not None:
            if isinstance(self.__child2Url, six.string_types):
                str += ' child2Url="'+self.__child2Url+'"'
            else:
                str += ' child2Url="'+self.__child2Url[0]+'"'
        if self.__child3Url is not None:
            if isinstance(self.__child3Url, six.string_types):
                str += ' child3Url="'+self.__child3Url+'"'
            else:
                str += ' child3Url="'+self.__child3Url[0]+'"'
        if self.__child4Url is not None:
            if isinstance(self.__child4Url, six.string_types):
                str += ' child4Url="'+self.__child4Url+'"'
            else:
                str += ' child4Url="'+self.__child4Url[0]+'"'
        if self.__geoSystem is not None:
            if isinstance(self.__geoSystem, six.string_types):
                str += ' geoSystem="'+self.__geoSystem+'"'
            else:
                str += ' geoSystem="'+self.__geoSystem[0]+'"'
        if self.__level_changed is not None:
            if isinstance(self.__level_changed, six.string_types):
                str += ' level_changed="'+self.__level_changed+'"'
            else:
                str += ' level_changed="'+self.__level_changed[0]+'"'
        if self.__range is not None:
            if isinstance(self.__range, six.string_types):
                str += ' range="'+self.__range+'"'
            else:
                str += ' range="'+self.__range[0]+'"'
        if self.__rootUrl is not None:
            if isinstance(self.__rootUrl, six.string_types):
                str += ' rootUrl="'+self.__rootUrl+'"'
            else:
                str += ' rootUrl="'+self.__rootUrl[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '<geoOrigin'
        if self.__geoOrigin is not None:
           for s in self.__geoOrigin:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__geoOrigin is not None:
           for s in self.__geoOrigin:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</geoOrigin>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<rootNode'
        if self.__rootNode is not None:
           for s in self.__rootNode:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__rootNode is not None:
           for s in self.__rootNode:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</rootNode>'
        str += '</GeoLOD>'
        return str


class GeoMetadata(X3DUrlObject, X3DInfoNode):
    def __init__(self, **kwargs):
        super(GeoMetadata, self).__init__(**kwargs)
        data  = kwargs.pop("data", None)
        self.__data = data
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        summary  = kwargs.pop("summary", None)
        self.__summary = summary
        url  = kwargs.pop("url", None)
        self.__url = url
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def data(self):
        return self.__data
    @data.setter
    def data(self, value = None):
        self.__data = [value]
    def setData(self, data = None):
        self.__data = [data]
        return self
    def addData(self, data = None):
        if self.__data == None:            self.__data =  []
        self.__data +=  [data]
        return self
    def removeData(self, data):
        self.__data = [x for x in self.__data if x not in data]
        return self.__data
    def getData(self, data = None):
        return self.__data
    def data_changed(self, data = None):
        return self.__data
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def summary(self):
        return self.__summary
    @summary.setter
    def summary(self, value = None):
        self.__summary = [value]
    def setSummary(self, summary = None):
        self.__summary = [summary]
        return self
    def addSummary(self, summary = None):
        if self.__summary == None:            self.__summary =  []
        self.__summary +=  [summary]
        return self
    def removeSummary(self, summary):
        self.__summary = [x for x in self.__summary if x not in summary]
        return self.__summary
    def getSummary(self, summary = None):
        return self.__summary
    def summary_changed(self, summary = None):
        return self.__summary
    @property
    def url(self):
        return self.__url
    @url.setter
    def url(self, value = None):
        self.__url = [value]
    def setUrl(self, url = None):
        self.__url = [url]
        return self
    def addUrl(self, url = None):
        if self.__url == None:            self.__url =  []
        self.__url +=  [url]
        return self
    def removeUrl(self, url):
        self.__url = [x for x in self.__url if x not in url]
        return self.__url
    def getUrl(self, url = None):
        return self.__url
    def url_changed(self, url = None):
        return self.__url
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<GeoMetadata'
        if self.__summary is not None:
            if isinstance(self.__summary, six.string_types):
                str += ' summary="'+self.__summary+'"'
            else:
                str += ' summary="'+self.__summary[0]+'"'
        if self.__url is not None:
            if isinstance(self.__url, six.string_types):
                str += ' url="'+self.__url+'"'
            else:
                str += ' url="'+self.__url[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<data'
        if self.__data is not None:
           for s in self.__data:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__data is not None:
           for s in self.__data:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</data>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</GeoMetadata>'
        return str


class GeoOrigin(X3DNode):
    def __init__(self, **kwargs):
        super(GeoOrigin, self).__init__(**kwargs)
        geoCoords  = kwargs.pop("geoCoords", [0, 0, 0])
        self.__geoCoords = geoCoords
        geoSystem  = kwargs.pop("geoSystem", ["GD", "WE"])
        self.__geoSystem = geoSystem
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        rotateYUp  = kwargs.pop("rotateYUp", False)
        self.__rotateYUp = rotateYUp
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def geoCoords(self):
        return self.__geoCoords
    @geoCoords.setter
    def geoCoords(self, value = [0, 0, 0]):
        self.__geoCoords = [value]
    def setGeoCoords(self, geoCoords = [0, 0, 0]):
        self.__geoCoords = [geoCoords]
        return self
    def addGeoCoords(self, geoCoords = [0, 0, 0]):
        if self.__geoCoords == None:            self.__geoCoords =  []
        self.__geoCoords +=  [geoCoords]
        return self
    def removeGeoCoords(self, geoCoords):
        self.__geoCoords = [x for x in self.__geoCoords if x not in geoCoords]
        return self.__geoCoords
    def getGeoCoords(self, geoCoords = [0, 0, 0]):
        return self.__geoCoords
    def geoCoords_changed(self, geoCoords = [0, 0, 0]):
        return self.__geoCoords
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<GeoOrigin'
        if self.__geoCoords is not None:
            if isinstance(self.__geoCoords, six.string_types):
                str += ' geoCoords="'+self.__geoCoords+'"'
            else:
                str += ' geoCoords="'+self.__geoCoords[0]+'"'
        if self.__geoSystem is not None:
            if isinstance(self.__geoSystem, six.string_types):
                str += ' geoSystem="'+self.__geoSystem+'"'
            else:
                str += ' geoSystem="'+self.__geoSystem[0]+'"'
        if self.__rotateYUp is not None:
            if isinstance(self.__rotateYUp, six.string_types):
                str += ' rotateYUp="'+self.__rotateYUp+'"'
            else:
                str += ' rotateYUp="'+self.__rotateYUp[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</GeoOrigin>'
        return str


class GeoPositionInterpolator(X3DInterpolatorNode):
    def __init__(self, **kwargs):
        super(GeoPositionInterpolator, self).__init__(**kwargs)
        geoOrigin  = kwargs.pop("geoOrigin", None)
        self.__geoOrigin = geoOrigin
        geoSystem  = kwargs.pop("geoSystem", ["GD", "WE"])
        self.__geoSystem = geoSystem
        geovalue_changed  = kwargs.pop("geovalue_changed", None)
        self.__geovalue_changed = geovalue_changed
        key  = kwargs.pop("key", None)
        self.__key = key
        keyValue  = kwargs.pop("keyValue", None)
        self.__keyValue = keyValue
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        fraction  = kwargs.pop("fraction", None)
        self.__fraction = fraction
        value_changed  = kwargs.pop("value_changed", None)
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def removegeovalue_changed(self, geovalue_changed):
        self.__geovalue_changed = [x for x in self.__geovalue_changed if x not in geovalue_changed]
        return self.__geovalue_changed
    def getgeovalue_changed(self, geovalue_changed = None):
        return self.__geovalue_changed
    def geovalue_changed_changed(self, geovalue_changed = None):
        return self.__geovalue_changed
    @property
    def key(self):
        return self.__key
    @key.setter
    def key(self, value = None):
        self.__key = [value]
    def setKey(self, key = None):
        self.__key = [key]
        return self
    def addKey(self, key = None):
        if self.__key == None:            self.__key =  []
        self.__key +=  [key]
        return self
    def removeKey(self, key):
        self.__key = [x for x in self.__key if x not in key]
        return self.__key
    def getKey(self, key = None):
        return self.__key
    def key_changed(self, key = None):
        return self.__key
    @property
    def keyValue(self):
        return self.__keyValue
    @keyValue.setter
    def keyValue(self, value = None):
        self.__keyValue = [value]
    def setKeyValue(self, keyValue = None):
        self.__keyValue = [keyValue]
        return self
    def addKeyValue(self, keyValue = None):
        if self.__keyValue == None:            self.__keyValue =  []
        self.__keyValue +=  [keyValue]
        return self
    def removeKeyValue(self, keyValue):
        self.__keyValue = [x for x in self.__keyValue if x not in keyValue]
        return self.__keyValue
    def getKeyValue(self, keyValue = None):
        return self.__keyValue
    def keyValue_changed(self, keyValue = None):
        return self.__keyValue
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def fraction(self):
        return self.__fraction
    @fraction.setter
    def fraction(self, value = None):
        self.__fraction = [value]
    def set_fraction(self, fraction = None):
        self.__fraction = [fraction]
        return self
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<GeoPositionInterpolator'
        if self.__geoSystem is not None:
            if isinstance(self.__geoSystem, six.string_types):
                str += ' geoSystem="'+self.__geoSystem+'"'
            else:
                str += ' geoSystem="'+self.__geoSystem[0]+'"'
        if self.__geovalue_changed is not None:
            if isinstance(self.__geovalue_changed, six.string_types):
                str += ' geovalue_changed="'+self.__geovalue_changed+'"'
            else:
                str += ' geovalue_changed="'+self.__geovalue_changed[0]+'"'
        if self.__key is not None:
            if isinstance(self.__key, six.string_types):
                str += ' key="'+self.__key+'"'
            else:
                str += ' key="'+self.__key[0]+'"'
        if self.__keyValue is not None:
            if isinstance(self.__keyValue, six.string_types):
                str += ' keyValue="'+self.__keyValue+'"'
            else:
                str += ' keyValue="'+self.__keyValue[0]+'"'
        if self.__fraction is not None:
            if isinstance(self.__fraction, six.string_types):
                str += ' fraction="'+self.__fraction+'"'
            else:
                str += ' fraction="'+self.__fraction[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<geoOrigin'
        if self.__geoOrigin is not None:
           for s in self.__geoOrigin:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__geoOrigin is not None:
           for s in self.__geoOrigin:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</geoOrigin>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</GeoPositionInterpolator>'
        return str


class GeoProximitySensor(X3DEnvironmentalSensorNode):
    def __init__(self, **kwargs):
        super(GeoProximitySensor, self).__init__(**kwargs)
        center  = kwargs.pop("center", [0, 0, 0])
        self.__center = center
        centerOfRotation_changed  = kwargs.pop("centerOfRotation_changed", None)
        self.__centerOfRotation_changed = centerOfRotation_changed
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        enterTime  = kwargs.pop("enterTime", None)
        self.__enterTime = enterTime
        exitTime  = kwargs.pop("exitTime", None)
        self.__exitTime = exitTime
        geoCenter  = kwargs.pop("geoCenter", [0, 0, 0])
        self.__geoCenter = geoCenter
        geoCoord_changed  = kwargs.pop("geoCoord_changed", None)
        self.__geoCoord_changed = geoCoord_changed
        geoOrigin  = kwargs.pop("geoOrigin", None)
        self.__geoOrigin = geoOrigin
        geoSystem  = kwargs.pop("geoSystem", ["GD", "WE"])
        self.__geoSystem = geoSystem
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        orientation_changed  = kwargs.pop("orientation_changed", None)
        self.__orientation_changed = orientation_changed
        position_changed  = kwargs.pop("position_changed", None)
        self.__position_changed = position_changed
        size  = kwargs.pop("size", [0, 0, 0])
        if size == None or len(size) <= 0 or min(size)  <  0:
            return None
        self.__size = size
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def center(self):
        return self.__center
    @center.setter
    def center(self, value = [0, 0, 0]):
        self.__center = [value]
    def setCenter(self, center = [0, 0, 0]):
        self.__center = [center]
        return self
    def addCenter(self, center = [0, 0, 0]):
        if self.__center == None:            self.__center =  []
        self.__center +=  [center]
        return self
    def removeCenter(self, center):
        self.__center = [x for x in self.__center if x not in center]
        return self.__center
    def getCenter(self, center = [0, 0, 0]):
        return self.__center
    def center_changed(self, center = [0, 0, 0]):
        return self.__center
    def removecenterOfRotation_changed(self, centerOfRotation_changed):
        self.__centerOfRotation_changed = [x for x in self.__centerOfRotation_changed if x not in centerOfRotation_changed]
        return self.__centerOfRotation_changed
    def getcenterOfRotation_changed(self, centerOfRotation_changed = None):
        return self.__centerOfRotation_changed
    def centerOfRotation_changed_changed(self, centerOfRotation_changed = None):
        return self.__centerOfRotation_changed
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    def removeEnterTime(self, enterTime):
        self.__enterTime = [x for x in self.__enterTime if x not in enterTime]
        return self.__enterTime
    def getEnterTime(self, enterTime = None):
        return self.__enterTime
    def enterTime_changed(self, enterTime = None):
        return self.__enterTime
    def removeExitTime(self, exitTime):
        self.__exitTime = [x for x in self.__exitTime if x not in exitTime]
        return self.__exitTime
    def getExitTime(self, exitTime = None):
        return self.__exitTime
    def exitTime_changed(self, exitTime = None):
        return self.__exitTime
    @property
    def geoCenter(self):
        return self.__geoCenter
    @geoCenter.setter
    def geoCenter(self, value = [0, 0, 0]):
        self.__geoCenter = [value]
    def setGeoCenter(self, geoCenter = [0, 0, 0]):
        self.__geoCenter = [geoCenter]
        return self
    def addGeoCenter(self, geoCenter = [0, 0, 0]):
        if self.__geoCenter == None:            self.__geoCenter =  []
        self.__geoCenter +=  [geoCenter]
        return self
    def removeGeoCenter(self, geoCenter):
        self.__geoCenter = [x for x in self.__geoCenter if x not in geoCenter]
        return self.__geoCenter
    def getGeoCenter(self, geoCenter = [0, 0, 0]):
        return self.__geoCenter
    def geoCenter_changed(self, geoCenter = [0, 0, 0]):
        return self.__geoCenter
    def removegeoCoord_changed(self, geoCoord_changed):
        self.__geoCoord_changed = [x for x in self.__geoCoord_changed if x not in geoCoord_changed]
        return self.__geoCoord_changed
    def getgeoCoord_changed(self, geoCoord_changed = None):
        return self.__geoCoord_changed
    def geoCoord_changed_changed(self, geoCoord_changed = None):
        return self.__geoCoord_changed
    def isActive(self, Active = None):
        return self.__Active
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    def removeorientation_changed(self, orientation_changed):
        self.__orientation_changed = [x for x in self.__orientation_changed if x not in orientation_changed]
        return self.__orientation_changed
    def getorientation_changed(self, orientation_changed = None):
        return self.__orientation_changed
    def orientation_changed_changed(self, orientation_changed = None):
        return self.__orientation_changed
    def removeposition_changed(self, position_changed):
        self.__position_changed = [x for x in self.__position_changed if x not in position_changed]
        return self.__position_changed
    def getposition_changed(self, position_changed = None):
        return self.__position_changed
    def position_changed_changed(self, position_changed = None):
        return self.__position_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<GeoProximitySensor'
        if self.__center is not None:
            if isinstance(self.__center, six.string_types):
                str += ' center="'+self.__center+'"'
            else:
                str += ' center="'+self.__center[0]+'"'
        if self.__centerOfRotation_changed is not None:
            if isinstance(self.__centerOfRotation_changed, six.string_types):
                str += ' centerOfRotation_changed="'+self.__centerOfRotation_changed+'"'
            else:
                str += ' centerOfRotation_changed="'+self.__centerOfRotation_changed[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__enterTime is not None:
            if isinstance(self.__enterTime, six.string_types):
                str += ' enterTime="'+self.__enterTime+'"'
            else:
                str += ' enterTime="'+self.__enterTime[0]+'"'
        if self.__exitTime is not None:
            if isinstance(self.__exitTime, six.string_types):
                str += ' exitTime="'+self.__exitTime+'"'
            else:
                str += ' exitTime="'+self.__exitTime[0]+'"'
        if self.__geoCenter is not None:
            if isinstance(self.__geoCenter, six.string_types):
                str += ' geoCenter="'+self.__geoCenter+'"'
            else:
                str += ' geoCenter="'+self.__geoCenter[0]+'"'
        if self.__geoCoord_changed is not None:
            if isinstance(self.__geoCoord_changed, six.string_types):
                str += ' geoCoord_changed="'+self.__geoCoord_changed+'"'
            else:
                str += ' geoCoord_changed="'+self.__geoCoord_changed[0]+'"'
        if self.__geoSystem is not None:
            if isinstance(self.__geoSystem, six.string_types):
                str += ' geoSystem="'+self.__geoSystem+'"'
            else:
                str += ' geoSystem="'+self.__geoSystem[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__orientation_changed is not None:
            if isinstance(self.__orientation_changed, six.string_types):
                str += ' orientation_changed="'+self.__orientation_changed+'"'
            else:
                str += ' orientation_changed="'+self.__orientation_changed[0]+'"'
        if self.__position_changed is not None:
            if isinstance(self.__position_changed, six.string_types):
                str += ' position_changed="'+self.__position_changed+'"'
            else:
                str += ' position_changed="'+self.__position_changed[0]+'"'
        if self.__size is not None:
            if isinstance(self.__size, six.string_types):
                str += ' size="'+self.__size+'"'
            else:
                str += ' size="'+self.__size[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<geoOrigin'
        if self.__geoOrigin is not None:
           for s in self.__geoOrigin:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__geoOrigin is not None:
           for s in self.__geoOrigin:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</geoOrigin>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</GeoProximitySensor>'
        return str


class GeoTouchSensor(X3DTouchSensorNode):
    def __init__(self, **kwargs):
        super(GeoTouchSensor, self).__init__(**kwargs)
        description  = kwargs.pop("description", None)
        self.__description = description
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        geoOrigin  = kwargs.pop("geoOrigin", None)
        self.__geoOrigin = geoOrigin
        geoSystem  = kwargs.pop("geoSystem", ["GD", "WE"])
        self.__geoSystem = geoSystem
        hitGeoCoord_changed  = kwargs.pop("hitGeoCoord_changed", None)
        self.__hitGeoCoord_changed = hitGeoCoord_changed
        hitNormal_changed  = kwargs.pop("hitNormal_changed", None)
        self.__hitNormal_changed = hitNormal_changed
        hitPoint_changed  = kwargs.pop("hitPoint_changed", None)
        self.__hitPoint_changed = hitPoint_changed
        hitTexCoord_changed  = kwargs.pop("hitTexCoord_changed", None)
        self.__hitTexCoord_changed = hitTexCoord_changed
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        Over  = kwargs.pop("Over", None)
        self.__Over = Over
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        touchTime  = kwargs.pop("touchTime", None)
        self.__touchTime = touchTime
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def description(self):
        return self.__description
    @description.setter
    def description(self, value = None):
        self.__description = [value]
    def setDescription(self, description = None):
        self.__description = [description]
        return self
    def addDescription(self, description = None):
        if self.__description == None:            self.__description =  []
        self.__description +=  [description]
        return self
    def removeDescription(self, description):
        self.__description = [x for x in self.__description if x not in description]
        return self.__description
    def getDescription(self, description = None):
        return self.__description
    def description_changed(self, description = None):
        return self.__description
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    def removehitGeoCoord_changed(self, hitGeoCoord_changed):
        self.__hitGeoCoord_changed = [x for x in self.__hitGeoCoord_changed if x not in hitGeoCoord_changed]
        return self.__hitGeoCoord_changed
    def gethitGeoCoord_changed(self, hitGeoCoord_changed = None):
        return self.__hitGeoCoord_changed
    def hitGeoCoord_changed_changed(self, hitGeoCoord_changed = None):
        return self.__hitGeoCoord_changed
    def removehitNormal_changed(self, hitNormal_changed):
        self.__hitNormal_changed = [x for x in self.__hitNormal_changed if x not in hitNormal_changed]
        return self.__hitNormal_changed
    def gethitNormal_changed(self, hitNormal_changed = None):
        return self.__hitNormal_changed
    def hitNormal_changed_changed(self, hitNormal_changed = None):
        return self.__hitNormal_changed
    def removehitPoint_changed(self, hitPoint_changed):
        self.__hitPoint_changed = [x for x in self.__hitPoint_changed if x not in hitPoint_changed]
        return self.__hitPoint_changed
    def gethitPoint_changed(self, hitPoint_changed = None):
        return self.__hitPoint_changed
    def hitPoint_changed_changed(self, hitPoint_changed = None):
        return self.__hitPoint_changed
    def removehitTexCoord_changed(self, hitTexCoord_changed):
        self.__hitTexCoord_changed = [x for x in self.__hitTexCoord_changed if x not in hitTexCoord_changed]
        return self.__hitTexCoord_changed
    def gethitTexCoord_changed(self, hitTexCoord_changed = None):
        return self.__hitTexCoord_changed
    def hitTexCoord_changed_changed(self, hitTexCoord_changed = None):
        return self.__hitTexCoord_changed
    def isActive(self, Active = None):
        return self.__Active
    def isOver(self, Over = None):
        return self.__Over
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    def removeTouchTime(self, touchTime):
        self.__touchTime = [x for x in self.__touchTime if x not in touchTime]
        return self.__touchTime
    def getTouchTime(self, touchTime = None):
        return self.__touchTime
    def touchTime_changed(self, touchTime = None):
        return self.__touchTime
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<GeoTouchSensor'
        if self.__description is not None:
            if isinstance(self.__description, six.string_types):
                str += ' description="'+self.__description+'"'
            else:
                str += ' description="'+self.__description[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__geoSystem is not None:
            if isinstance(self.__geoSystem, six.string_types):
                str += ' geoSystem="'+self.__geoSystem+'"'
            else:
                str += ' geoSystem="'+self.__geoSystem[0]+'"'
        if self.__hitGeoCoord_changed is not None:
            if isinstance(self.__hitGeoCoord_changed, six.string_types):
                str += ' hitGeoCoord_changed="'+self.__hitGeoCoord_changed+'"'
            else:
                str += ' hitGeoCoord_changed="'+self.__hitGeoCoord_changed[0]+'"'
        if self.__hitNormal_changed is not None:
            if isinstance(self.__hitNormal_changed, six.string_types):
                str += ' hitNormal_changed="'+self.__hitNormal_changed+'"'
            else:
                str += ' hitNormal_changed="'+self.__hitNormal_changed[0]+'"'
        if self.__hitPoint_changed is not None:
            if isinstance(self.__hitPoint_changed, six.string_types):
                str += ' hitPoint_changed="'+self.__hitPoint_changed+'"'
            else:
                str += ' hitPoint_changed="'+self.__hitPoint_changed[0]+'"'
        if self.__hitTexCoord_changed is not None:
            if isinstance(self.__hitTexCoord_changed, six.string_types):
                str += ' hitTexCoord_changed="'+self.__hitTexCoord_changed+'"'
            else:
                str += ' hitTexCoord_changed="'+self.__hitTexCoord_changed[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__Over is not None:
            if isinstance(self.__Over, six.string_types):
                str += ' Over="'+self.__Over+'"'
            else:
                str += ' Over="'+self.__Over[0]+'"'
        if self.__touchTime is not None:
            if isinstance(self.__touchTime, six.string_types):
                str += ' touchTime="'+self.__touchTime+'"'
            else:
                str += ' touchTime="'+self.__touchTime[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<geoOrigin'
        if self.__geoOrigin is not None:
           for s in self.__geoOrigin:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__geoOrigin is not None:
           for s in self.__geoOrigin:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</geoOrigin>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</GeoTouchSensor>'
        return str


class GeoTransform(X3DGroupingNode):
    def __init__(self, **kwargs):
        super(GeoTransform, self).__init__(**kwargs)
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        children  = kwargs.pop("children", None)
        self.__children = children
        geoCenter  = kwargs.pop("geoCenter", [0, 0, 0])
        self.__geoCenter = geoCenter
        geoOrigin  = kwargs.pop("geoOrigin", None)
        self.__geoOrigin = geoOrigin
        geoSystem  = kwargs.pop("geoSystem", ["GD", "WE"])
        self.__geoSystem = geoSystem
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        rotation  = kwargs.pop("rotation", [0, 0, 1, 0])
        self.__rotation = rotation
        scale  = kwargs.pop("scale", [1, 1, 1])
        if scale == None or len(scale) <= 0 or min(scale)  <=  0:
            return None
        self.__scale = scale
        scaleOrientation  = kwargs.pop("scaleOrientation", [0, 0, 1, 0])
        self.__scaleOrientation = scaleOrientation
        translation  = kwargs.pop("translation", [0, 0, 0])
        self.__translation = translation
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    def addChildren(self, Children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [Children]
        return self
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    @property
    def geoCenter(self):
        return self.__geoCenter
    @geoCenter.setter
    def geoCenter(self, value = [0, 0, 0]):
        self.__geoCenter = [value]
    def setGeoCenter(self, geoCenter = [0, 0, 0]):
        self.__geoCenter = [geoCenter]
        return self
    def addGeoCenter(self, geoCenter = [0, 0, 0]):
        if self.__geoCenter == None:            self.__geoCenter =  []
        self.__geoCenter +=  [geoCenter]
        return self
    def removeGeoCenter(self, geoCenter):
        self.__geoCenter = [x for x in self.__geoCenter if x not in geoCenter]
        return self.__geoCenter
    def getGeoCenter(self, geoCenter = [0, 0, 0]):
        return self.__geoCenter
    def geoCenter_changed(self, geoCenter = [0, 0, 0]):
        return self.__geoCenter
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    @property
    def rotation(self):
        return self.__rotation
    @rotation.setter
    def rotation(self, value = [0, 0, 1, 0]):
        self.__rotation = [value]
    def setRotation(self, rotation = [0, 0, 1, 0]):
        self.__rotation = [rotation]
        return self
    def addRotation(self, rotation = [0, 0, 1, 0]):
        if self.__rotation == None:            self.__rotation =  []
        self.__rotation +=  [rotation]
        return self
    def removeRotation(self, rotation):
        self.__rotation = [x for x in self.__rotation if x not in rotation]
        return self.__rotation
    def getRotation(self, rotation = [0, 0, 1, 0]):
        return self.__rotation
    def rotation_changed(self, rotation = [0, 0, 1, 0]):
        return self.__rotation
    @property
    def scale(self):
        return self.__scale
    @scale.setter
    def scale(self, value = [1, 1, 1]):
        if value == None or len(value) <= 0 or min(value)  <=  0:
            return None
        self.__scale = [value]
    def setScale(self, scale = [1, 1, 1]):
        if scale == None or len(scale) <= 0 or min(scale)  <=  0:
            return None
        self.__scale = [scale]
        return self
    def addScale(self, scale = [1, 1, 1]):
        if scale == None or len(scale) <= 0 or min(scale)  <=  0:
            return None
        if self.__scale == None:            self.__scale =  []
        self.__scale +=  [scale]
        return self
    def removeScale(self, scale):
        self.__scale = [x for x in self.__scale if x not in scale]
        return self.__scale
    def getScale(self, scale = [1, 1, 1]):
        return self.__scale
    def scale_changed(self, scale = [1, 1, 1]):
        return self.__scale
    @property
    def scaleOrientation(self):
        return self.__scaleOrientation
    @scaleOrientation.setter
    def scaleOrientation(self, value = [0, 0, 1, 0]):
        self.__scaleOrientation = [value]
    def setScaleOrientation(self, scaleOrientation = [0, 0, 1, 0]):
        self.__scaleOrientation = [scaleOrientation]
        return self
    def addScaleOrientation(self, scaleOrientation = [0, 0, 1, 0]):
        if self.__scaleOrientation == None:            self.__scaleOrientation =  []
        self.__scaleOrientation +=  [scaleOrientation]
        return self
    def removeScaleOrientation(self, scaleOrientation):
        self.__scaleOrientation = [x for x in self.__scaleOrientation if x not in scaleOrientation]
        return self.__scaleOrientation
    def getScaleOrientation(self, scaleOrientation = [0, 0, 1, 0]):
        return self.__scaleOrientation
    def scaleOrientation_changed(self, scaleOrientation = [0, 0, 1, 0]):
        return self.__scaleOrientation
    @property
    def translation(self):
        return self.__translation
    @translation.setter
    def translation(self, value = [0, 0, 0]):
        self.__translation = [value]
    def setTranslation(self, translation = [0, 0, 0]):
        self.__translation = [translation]
        return self
    def addTranslation(self, translation = [0, 0, 0]):
        if self.__translation == None:            self.__translation =  []
        self.__translation +=  [translation]
        return self
    def removeTranslation(self, translation):
        self.__translation = [x for x in self.__translation if x not in translation]
        return self.__translation
    def getTranslation(self, translation = [0, 0, 0]):
        return self.__translation
    def translation_changed(self, translation = [0, 0, 0]):
        return self.__translation
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<GeoTransform'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__geoCenter is not None:
            if isinstance(self.__geoCenter, six.string_types):
                str += ' geoCenter="'+self.__geoCenter+'"'
            else:
                str += ' geoCenter="'+self.__geoCenter[0]+'"'
        if self.__geoSystem is not None:
            if isinstance(self.__geoSystem, six.string_types):
                str += ' geoSystem="'+self.__geoSystem+'"'
            else:
                str += ' geoSystem="'+self.__geoSystem[0]+'"'
        if self.__rotation is not None:
            if isinstance(self.__rotation, six.string_types):
                str += ' rotation="'+self.__rotation+'"'
            else:
                str += ' rotation="'+self.__rotation[0]+'"'
        if self.__scale is not None:
            if isinstance(self.__scale, six.string_types):
                str += ' scale="'+self.__scale+'"'
            else:
                str += ' scale="'+self.__scale[0]+'"'
        if self.__scaleOrientation is not None:
            if isinstance(self.__scaleOrientation, six.string_types):
                str += ' scaleOrientation="'+self.__scaleOrientation+'"'
            else:
                str += ' scaleOrientation="'+self.__scaleOrientation[0]+'"'
        if self.__translation is not None:
            if isinstance(self.__translation, six.string_types):
                str += ' translation="'+self.__translation+'"'
            else:
                str += ' translation="'+self.__translation[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '<geoOrigin'
        if self.__geoOrigin is not None:
           for s in self.__geoOrigin:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__geoOrigin is not None:
           for s in self.__geoOrigin:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</geoOrigin>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '</GeoTransform>'
        return str


class GeoViewpoint(X3DViewpointNode):
    def __init__(self, **kwargs):
        super(GeoViewpoint, self).__init__(**kwargs)
        bindTime  = kwargs.pop("bindTime", None)
        self.__bindTime = bindTime
        centerOfRotation  = kwargs.pop("centerOfRotation", [0, 0, 0])
        self.__centerOfRotation = centerOfRotation
        description  = kwargs.pop("description", None)
        self.__description = description
        fieldOfView  = kwargs.pop("fieldOfView", 0.7854)
        if fieldOfView == None or fieldOfView  <=  0:
            return None
        if fieldOfView == None or fieldOfView  >=  3.1416:
            return None
        self.__fieldOfView = fieldOfView
        geoOrigin  = kwargs.pop("geoOrigin", None)
        self.__geoOrigin = geoOrigin
        geoSystem  = kwargs.pop("geoSystem", ["GD", "WE"])
        self.__geoSystem = geoSystem
        Bound  = kwargs.pop("Bound", None)
        self.__Bound = Bound
        jump  = kwargs.pop("jump", True)
        self.__jump = jump
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        orientation  = kwargs.pop("orientation", [0, 0, 1, 0])
        self.__orientation = orientation
        position  = kwargs.pop("position", [0, 0, 100000])
        self.__position = position
        retainUserOffsets  = kwargs.pop("retainUserOffsets", False)
        self.__retainUserOffsets = retainUserOffsets
        bind  = kwargs.pop("bind", None)
        self.__bind = bind
        speedFactor  = kwargs.pop("speedFactor", 1.0)
        if speedFactor == None or speedFactor  <  0:
            return None
        self.__speedFactor = speedFactor
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def removeBindTime(self, bindTime):
        self.__bindTime = [x for x in self.__bindTime if x not in bindTime]
        return self.__bindTime
    def getBindTime(self, bindTime = None):
        return self.__bindTime
    def bindTime_changed(self, bindTime = None):
        return self.__bindTime
    @property
    def centerOfRotation(self):
        return self.__centerOfRotation
    @centerOfRotation.setter
    def centerOfRotation(self, value = [0, 0, 0]):
        self.__centerOfRotation = [value]
    def setCenterOfRotation(self, centerOfRotation = [0, 0, 0]):
        self.__centerOfRotation = [centerOfRotation]
        return self
    def addCenterOfRotation(self, centerOfRotation = [0, 0, 0]):
        if self.__centerOfRotation == None:            self.__centerOfRotation =  []
        self.__centerOfRotation +=  [centerOfRotation]
        return self
    def removeCenterOfRotation(self, centerOfRotation):
        self.__centerOfRotation = [x for x in self.__centerOfRotation if x not in centerOfRotation]
        return self.__centerOfRotation
    def getCenterOfRotation(self, centerOfRotation = [0, 0, 0]):
        return self.__centerOfRotation
    def centerOfRotation_changed(self, centerOfRotation = [0, 0, 0]):
        return self.__centerOfRotation
    @property
    def description(self):
        return self.__description
    @description.setter
    def description(self, value = None):
        self.__description = [value]
    def setDescription(self, description = None):
        self.__description = [description]
        return self
    def addDescription(self, description = None):
        if self.__description == None:            self.__description =  []
        self.__description +=  [description]
        return self
    def removeDescription(self, description):
        self.__description = [x for x in self.__description if x not in description]
        return self.__description
    def getDescription(self, description = None):
        return self.__description
    def description_changed(self, description = None):
        return self.__description
    @property
    def fieldOfView(self):
        return self.__fieldOfView
    @fieldOfView.setter
    def fieldOfView(self, value = 0.7854):
        if value == None or value  <=  0:
            return None
        if value == None or value  >=  3.1416:
            return None
        self.__fieldOfView = [value]
    def setFieldOfView(self, fieldOfView = 0.7854):
        if fieldOfView == None or fieldOfView  <=  0:
            return None
        if fieldOfView == None or fieldOfView  >=  3.1416:
            return None
        self.__fieldOfView = [fieldOfView]
        return self
    def addFieldOfView(self, fieldOfView = 0.7854):
        if fieldOfView == None or fieldOfView  <=  0:
            return None
        if fieldOfView == None or fieldOfView  >=  3.1416:
            return None
        if self.__fieldOfView == None:            self.__fieldOfView =  []
        self.__fieldOfView +=  [fieldOfView]
        return self
    def removeFieldOfView(self, fieldOfView):
        self.__fieldOfView = [x for x in self.__fieldOfView if x not in fieldOfView]
        return self.__fieldOfView
    def getFieldOfView(self, fieldOfView = 0.7854):
        return self.__fieldOfView
    def fieldOfView_changed(self, fieldOfView = 0.7854):
        return self.__fieldOfView
    def isBound(self, Bound = None):
        return self.__Bound
    @property
    def jump(self):
        return self.__jump
    @jump.setter
    def jump(self, value = True):
        self.__jump = [value]
    def setJump(self, jump = True):
        self.__jump = [jump]
        return self
    def addJump(self, jump = True):
        if self.__jump == None:            self.__jump =  []
        self.__jump +=  [jump]
        return self
    def removeJump(self, jump):
        self.__jump = [x for x in self.__jump if x not in jump]
        return self.__jump
    def isJump(self, jump = True):
        return self.__jump
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def orientation(self):
        return self.__orientation
    @orientation.setter
    def orientation(self, value = [0, 0, 1, 0]):
        self.__orientation = [value]
    def setOrientation(self, orientation = [0, 0, 1, 0]):
        self.__orientation = [orientation]
        return self
    def addOrientation(self, orientation = [0, 0, 1, 0]):
        if self.__orientation == None:            self.__orientation =  []
        self.__orientation +=  [orientation]
        return self
    def removeOrientation(self, orientation):
        self.__orientation = [x for x in self.__orientation if x not in orientation]
        return self.__orientation
    def getOrientation(self, orientation = [0, 0, 1, 0]):
        return self.__orientation
    def orientation_changed(self, orientation = [0, 0, 1, 0]):
        return self.__orientation
    @property
    def position(self):
        return self.__position
    @position.setter
    def position(self, value = [0, 0, 100000]):
        self.__position = [value]
    def setPosition(self, position = [0, 0, 100000]):
        self.__position = [position]
        return self
    def addPosition(self, position = [0, 0, 100000]):
        if self.__position == None:            self.__position =  []
        self.__position +=  [position]
        return self
    def removePosition(self, position):
        self.__position = [x for x in self.__position if x not in position]
        return self.__position
    def getPosition(self, position = [0, 0, 100000]):
        return self.__position
    def position_changed(self, position = [0, 0, 100000]):
        return self.__position
    @property
    def retainUserOffsets(self):
        return self.__retainUserOffsets
    @retainUserOffsets.setter
    def retainUserOffsets(self, value = False):
        self.__retainUserOffsets = [value]
    def setRetainUserOffsets(self, retainUserOffsets = False):
        self.__retainUserOffsets = [retainUserOffsets]
        return self
    def addRetainUserOffsets(self, retainUserOffsets = False):
        if self.__retainUserOffsets == None:            self.__retainUserOffsets =  []
        self.__retainUserOffsets +=  [retainUserOffsets]
        return self
    def removeRetainUserOffsets(self, retainUserOffsets):
        self.__retainUserOffsets = [x for x in self.__retainUserOffsets if x not in retainUserOffsets]
        return self.__retainUserOffsets
    def isRetainUserOffsets(self, retainUserOffsets = False):
        return self.__retainUserOffsets
    @property
    def bind(self):
        return self.__bind
    @bind.setter
    def bind(self, value = None):
        self.__bind = [value]
    def set_bind(self, bind = None):
        self.__bind = [bind]
        return self
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<GeoViewpoint'
        if self.__bindTime is not None:
            if isinstance(self.__bindTime, six.string_types):
                str += ' bindTime="'+self.__bindTime+'"'
            else:
                str += ' bindTime="'+self.__bindTime[0]+'"'
        if self.__centerOfRotation is not None:
            if isinstance(self.__centerOfRotation, six.string_types):
                str += ' centerOfRotation="'+self.__centerOfRotation+'"'
            else:
                str += ' centerOfRotation="'+self.__centerOfRotation[0]+'"'
        if self.__description is not None:
            if isinstance(self.__description, six.string_types):
                str += ' description="'+self.__description+'"'
            else:
                str += ' description="'+self.__description[0]+'"'
        if self.__fieldOfView is not None:
            if isinstance(self.__fieldOfView, six.string_types):
                str += ' fieldOfView="'+self.__fieldOfView+'"'
            else:
                str += ' fieldOfView="'+self.__fieldOfView[0]+'"'
        if self.__geoSystem is not None:
            if isinstance(self.__geoSystem, six.string_types):
                str += ' geoSystem="'+self.__geoSystem+'"'
            else:
                str += ' geoSystem="'+self.__geoSystem[0]+'"'
        if self.__Bound is not None:
            if isinstance(self.__Bound, six.string_types):
                str += ' Bound="'+self.__Bound+'"'
            else:
                str += ' Bound="'+self.__Bound[0]+'"'
        if self.__jump is not None:
            if isinstance(self.__jump, six.string_types):
                str += ' jump="'+self.__jump+'"'
            else:
                str += ' jump="'+self.__jump[0]+'"'
        if self.__orientation is not None:
            if isinstance(self.__orientation, six.string_types):
                str += ' orientation="'+self.__orientation+'"'
            else:
                str += ' orientation="'+self.__orientation[0]+'"'
        if self.__position is not None:
            if isinstance(self.__position, six.string_types):
                str += ' position="'+self.__position+'"'
            else:
                str += ' position="'+self.__position[0]+'"'
        if self.__retainUserOffsets is not None:
            if isinstance(self.__retainUserOffsets, six.string_types):
                str += ' retainUserOffsets="'+self.__retainUserOffsets+'"'
            else:
                str += ' retainUserOffsets="'+self.__retainUserOffsets[0]+'"'
        if self.__bind is not None:
            if isinstance(self.__bind, six.string_types):
                str += ' bind="'+self.__bind+'"'
            else:
                str += ' bind="'+self.__bind[0]+'"'
        if self.__speedFactor is not None:
            if isinstance(self.__speedFactor, six.string_types):
                str += ' speedFactor="'+self.__speedFactor+'"'
            else:
                str += ' speedFactor="'+self.__speedFactor[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<geoOrigin'
        if self.__geoOrigin is not None:
           for s in self.__geoOrigin:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__geoOrigin is not None:
           for s in self.__geoOrigin:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</geoOrigin>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</GeoViewpoint>'
        return str


class Group(X3DGroupingNode):
    def __init__(self, **kwargs):
        super(Group, self).__init__(**kwargs)
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        children  = kwargs.pop("children", None)
        self.__children = children
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    def addChildren(self, Children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [Children]
        return self
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    @property
    def IS(self):
        return self.__IS
    @IS.setter
    def IS(self, value = None):
        self.__IS = [value]
    def setIS(self, IS = None):
        self.__IS = [IS]
        return self
    def addIS(self, IS = None):
        if self.__IS == None:            self.__IS =  []
        self.__IS +=  [IS]
        return self
    def removeIS(self, IS):
        self.__IS = [x for x in self.__IS if x not in IS]
        return self.__IS
    def getIS(self, IS = None):
        return self.__IS
    def IS_changed(self, IS = None):
        return self.__IS
    def toXML(self):
        str = ''
        str += '<Group'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '</Group>'
        return str


class HAnimDisplacer(X3DGeometricPropertyNode):
    def __init__(self, **kwargs):
        super(HAnimDisplacer, self).__init__(**kwargs)
        coordIndex  = kwargs.pop("coordIndex", None)
        if coordIndex == None or len(coordIndex) <= 0 or min(coordIndex)  <  0:
            return None
        self.__coordIndex = coordIndex
        description  = kwargs.pop("description", None)
        self.__description = description
        displacements  = kwargs.pop("displacements", None)
        self.__displacements = displacements
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        name  = kwargs.pop("name", None)
        self.__name = name
        weight  = kwargs.pop("weight", 0.0)
        self.__weight = weight
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def description(self):
        return self.__description
    @description.setter
    def description(self, value = None):
        self.__description = [value]
    def setDescription(self, description = None):
        self.__description = [description]
        return self
    def addDescription(self, description = None):
        if self.__description == None:            self.__description =  []
        self.__description +=  [description]
        return self
    def removeDescription(self, description):
        self.__description = [x for x in self.__description if x not in description]
        return self.__description
    def getDescription(self, description = None):
        return self.__description
    def description_changed(self, description = None):
        return self.__description
    @property
    def displacements(self):
        return self.__displacements
    @displacements.setter
    def displacements(self, value = None):
        self.__displacements = [value]
    def setDisplacements(self, displacements = None):
        self.__displacements = [displacements]
        return self
    def addDisplacements(self, displacements = None):
        if self.__displacements == None:            self.__displacements =  []
        self.__displacements +=  [displacements]
        return self
    def removeDisplacements(self, displacements):
        self.__displacements = [x for x in self.__displacements if x not in displacements]
        return self.__displacements
    def getDisplacements(self, displacements = None):
        return self.__displacements
    def displacements_changed(self, displacements = None):
        return self.__displacements
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        self.__name = [value]
    def setName(self, name = None):
        self.__name = [name]
        return self
    def addName(self, name = None):
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def weight(self):
        return self.__weight
    @weight.setter
    def weight(self, value = 0.0):
        self.__weight = [value]
    def setWeight(self, weight = 0.0):
        self.__weight = [weight]
        return self
    def addWeight(self, weight = 0.0):
        if self.__weight == None:            self.__weight =  []
        self.__weight +=  [weight]
        return self
    def removeWeight(self, weight):
        self.__weight = [x for x in self.__weight if x not in weight]
        return self.__weight
    def getWeight(self, weight = 0.0):
        return self.__weight
    def weight_changed(self, weight = 0.0):
        return self.__weight
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<HAnimDisplacer'
        if self.__coordIndex is not None:
            if isinstance(self.__coordIndex, six.string_types):
                str += ' coordIndex="'+self.__coordIndex+'"'
            else:
                str += ' coordIndex="'+self.__coordIndex[0]+'"'
        if self.__description is not None:
            if isinstance(self.__description, six.string_types):
                str += ' description="'+self.__description+'"'
            else:
                str += ' description="'+self.__description[0]+'"'
        if self.__displacements is not None:
            if isinstance(self.__displacements, six.string_types):
                str += ' displacements="'+self.__displacements+'"'
            else:
                str += ' displacements="'+self.__displacements[0]+'"'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        if self.__weight is not None:
            if isinstance(self.__weight, six.string_types):
                str += ' weight="'+self.__weight+'"'
            else:
                str += ' weight="'+self.__weight[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</HAnimDisplacer>'
        return str


class HAnimHumanoid(X3DBoundedObject, X3DChildNode):
    def __init__(self, **kwargs):
        super(HAnimHumanoid, self).__init__(**kwargs)
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        center  = kwargs.pop("center", [0, 0, 0])
        self.__center = center
        description  = kwargs.pop("description", None)
        self.__description = description
        info  = kwargs.pop("info", None)
        self.__info = info
        jointBindingPositions  = kwargs.pop("jointBindingPositions", [0, 0, 0])
        self.__jointBindingPositions = jointBindingPositions
        jointBindingRotations  = kwargs.pop("jointBindingRotations", [0, 0, 1, 0])
        self.__jointBindingRotations = jointBindingRotations
        jointBindingScales  = kwargs.pop("jointBindingScales", [0, 0, 0])
        self.__jointBindingScales = jointBindingScales
        joints  = kwargs.pop("joints", None)
        self.__joints = joints
        loa  = kwargs.pop("loa", -1)
        if loa == None or loa  <  -1:
            return None
        if loa == None or loa  >  4:
            return None
        self.__loa = loa
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        motions  = kwargs.pop("motions", None)
        self.__motions = motions
        name  = kwargs.pop("name", None)
        self.__name = name
        rotation  = kwargs.pop("rotation", [0, 0, 1, 0])
        self.__rotation = rotation
        scale  = kwargs.pop("scale", [1, 1, 1])
        if scale == None or len(scale) <= 0 or min(scale)  <=  0:
            return None
        self.__scale = scale
        scaleOrientation  = kwargs.pop("scaleOrientation", [0, 0, 1, 0])
        self.__scaleOrientation = scaleOrientation
        segments  = kwargs.pop("segments", None)
        self.__segments = segments
        sites  = kwargs.pop("sites", None)
        self.__sites = sites
        skeletalConfiguration  = kwargs.pop("skeletalConfiguration", "BASIC")
        self.__skeletalConfiguration = skeletalConfiguration
        skeleton  = kwargs.pop("skeleton", None)
        self.__skeleton = skeleton
        skin  = kwargs.pop("skin", None)
        self.__skin = skin
        skinBindingCoords  = kwargs.pop("skinBindingCoords", None)
        self.__skinBindingCoords = skinBindingCoords
        skinBindingNormals  = kwargs.pop("skinBindingNormals", None)
        self.__skinBindingNormals = skinBindingNormals
        skinCoord  = kwargs.pop("skinCoord", None)
        self.__skinCoord = skinCoord
        skinNormal  = kwargs.pop("skinNormal", None)
        self.__skinNormal = skinNormal
        translation  = kwargs.pop("translation", [0, 0, 0])
        self.__translation = translation
        version  = kwargs.pop("version", "2.0")
        if '1.0' == version:
            pass
        elif '1.1' == version:
            pass
        elif '2.0' == version:
            pass
        else:
            return None
        self.__version = version
        viewpoints  = kwargs.pop("viewpoints", None)
        self.__viewpoints = viewpoints
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def center(self):
        return self.__center
    @center.setter
    def center(self, value = [0, 0, 0]):
        self.__center = [value]
    def setCenter(self, center = [0, 0, 0]):
        self.__center = [center]
        return self
    def addCenter(self, center = [0, 0, 0]):
        if self.__center == None:            self.__center =  []
        self.__center +=  [center]
        return self
    def removeCenter(self, center):
        self.__center = [x for x in self.__center if x not in center]
        return self.__center
    def getCenter(self, center = [0, 0, 0]):
        return self.__center
    def center_changed(self, center = [0, 0, 0]):
        return self.__center
    @property
    def description(self):
        return self.__description
    @description.setter
    def description(self, value = None):
        self.__description = [value]
    def setDescription(self, description = None):
        self.__description = [description]
        return self
    def addDescription(self, description = None):
        if self.__description == None:            self.__description =  []
        self.__description +=  [description]
        return self
    def removeDescription(self, description):
        self.__description = [x for x in self.__description if x not in description]
        return self.__description
    def getDescription(self, description = None):
        return self.__description
    def description_changed(self, description = None):
        return self.__description
    @property
    def info(self):
        return self.__info
    @info.setter
    def info(self, value = None):
        self.__info = [value]
    def setInfo(self, info = None):
        self.__info = [info]
        return self
    def addInfo(self, info = None):
        if self.__info == None:            self.__info =  []
        self.__info +=  [info]
        return self
    def removeInfo(self, info):
        self.__info = [x for x in self.__info if x not in info]
        return self.__info
    def getInfo(self, info = None):
        return self.__info
    def info_changed(self, info = None):
        return self.__info
    @property
    def jointBindingPositions(self):
        return self.__jointBindingPositions
    @jointBindingPositions.setter
    def jointBindingPositions(self, value = [0, 0, 0]):
        self.__jointBindingPositions = [value]
    def setJointBindingPositions(self, jointBindingPositions = [0, 0, 0]):
        self.__jointBindingPositions = [jointBindingPositions]
        return self
    def addJointBindingPositions(self, jointBindingPositions = [0, 0, 0]):
        if self.__jointBindingPositions == None:            self.__jointBindingPositions =  []
        self.__jointBindingPositions +=  [jointBindingPositions]
        return self
    def removeJointBindingPositions(self, jointBindingPositions):
        self.__jointBindingPositions = [x for x in self.__jointBindingPositions if x not in jointBindingPositions]
        return self.__jointBindingPositions
    def getJointBindingPositions(self, jointBindingPositions = [0, 0, 0]):
        return self.__jointBindingPositions
    def jointBindingPositions_changed(self, jointBindingPositions = [0, 0, 0]):
        return self.__jointBindingPositions
    @property
    def jointBindingRotations(self):
        return self.__jointBindingRotations
    @jointBindingRotations.setter
    def jointBindingRotations(self, value = [0, 0, 1, 0]):
        self.__jointBindingRotations = [value]
    def setJointBindingRotations(self, jointBindingRotations = [0, 0, 1, 0]):
        self.__jointBindingRotations = [jointBindingRotations]
        return self
    def addJointBindingRotations(self, jointBindingRotations = [0, 0, 1, 0]):
        if self.__jointBindingRotations == None:            self.__jointBindingRotations =  []
        self.__jointBindingRotations +=  [jointBindingRotations]
        return self
    def removeJointBindingRotations(self, jointBindingRotations):
        self.__jointBindingRotations = [x for x in self.__jointBindingRotations if x not in jointBindingRotations]
        return self.__jointBindingRotations
    def getJointBindingRotations(self, jointBindingRotations = [0, 0, 1, 0]):
        return self.__jointBindingRotations
    def jointBindingRotations_changed(self, jointBindingRotations = [0, 0, 1, 0]):
        return self.__jointBindingRotations
    @property
    def jointBindingScales(self):
        return self.__jointBindingScales
    @jointBindingScales.setter
    def jointBindingScales(self, value = [0, 0, 0]):
        self.__jointBindingScales = [value]
    def setJointBindingScales(self, jointBindingScales = [0, 0, 0]):
        self.__jointBindingScales = [jointBindingScales]
        return self
    def addJointBindingScales(self, jointBindingScales = [0, 0, 0]):
        if self.__jointBindingScales == None:            self.__jointBindingScales =  []
        self.__jointBindingScales +=  [jointBindingScales]
        return self
    def removeJointBindingScales(self, jointBindingScales):
        self.__jointBindingScales = [x for x in self.__jointBindingScales if x not in jointBindingScales]
        return self.__jointBindingScales
    def getJointBindingScales(self, jointBindingScales = [0, 0, 0]):
        return self.__jointBindingScales
    def jointBindingScales_changed(self, jointBindingScales = [0, 0, 0]):
        return self.__jointBindingScales
    @property
    def joints(self):
        return self.__joints
    @joints.setter
    def joints(self, value = None):
        self.__joints = [value]
    def setJoints(self, joints = None):
        self.__joints = [joints]
        return self
    def addJoints(self, joints = None):
        if self.__joints == None:            self.__joints =  []
        self.__joints +=  [joints]
        return self
    def removeJoints(self, joints):
        self.__joints = [x for x in self.__joints if x not in joints]
        return self.__joints
    def getJoints(self, joints = None):
        return self.__joints
    def joints_changed(self, joints = None):
        return self.__joints
    @property
    def loa(self):
        return self.__loa
    @loa.setter
    def loa(self, value = -1):
        if value == None or value  <  -1:
            return None
        if value == None or value  >  4:
            return None
        self.__loa = [value]
    def setLoa(self, loa = -1):
        if loa == None or loa  <  -1:
            return None
        if loa == None or loa  >  4:
            return None
        self.__loa = [loa]
        return self
    def addLoa(self, loa = -1):
        if loa == None or loa  <  -1:
            return None
        if loa == None or loa  >  4:
            return None
        if self.__loa == None:            self.__loa =  []
        self.__loa +=  [loa]
        return self
    def removeLoa(self, loa):
        self.__loa = [x for x in self.__loa if x not in loa]
        return self.__loa
    def getLoa(self, loa = -1):
        return self.__loa
    def loa_changed(self, loa = -1):
        return self.__loa
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def motions(self):
        return self.__motions
    @motions.setter
    def motions(self, value = None):
        self.__motions = [value]
    def setMotions(self, motions = None):
        self.__motions = [motions]
        return self
    def addMotions(self, motions = None):
        if self.__motions == None:            self.__motions =  []
        self.__motions +=  [motions]
        return self
    def removeMotions(self, motions):
        self.__motions = [x for x in self.__motions if x not in motions]
        return self.__motions
    def getMotions(self, motions = None):
        return self.__motions
    def motions_changed(self, motions = None):
        return self.__motions
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        self.__name = [value]
    def setName(self, name = None):
        self.__name = [name]
        return self
    def addName(self, name = None):
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def rotation(self):
        return self.__rotation
    @rotation.setter
    def rotation(self, value = [0, 0, 1, 0]):
        self.__rotation = [value]
    def setRotation(self, rotation = [0, 0, 1, 0]):
        self.__rotation = [rotation]
        return self
    def addRotation(self, rotation = [0, 0, 1, 0]):
        if self.__rotation == None:            self.__rotation =  []
        self.__rotation +=  [rotation]
        return self
    def removeRotation(self, rotation):
        self.__rotation = [x for x in self.__rotation if x not in rotation]
        return self.__rotation
    def getRotation(self, rotation = [0, 0, 1, 0]):
        return self.__rotation
    def rotation_changed(self, rotation = [0, 0, 1, 0]):
        return self.__rotation
    @property
    def scale(self):
        return self.__scale
    @scale.setter
    def scale(self, value = [1, 1, 1]):
        if value == None or len(value) <= 0 or min(value)  <=  0:
            return None
        self.__scale = [value]
    def setScale(self, scale = [1, 1, 1]):
        if scale == None or len(scale) <= 0 or min(scale)  <=  0:
            return None
        self.__scale = [scale]
        return self
    def addScale(self, scale = [1, 1, 1]):
        if scale == None or len(scale) <= 0 or min(scale)  <=  0:
            return None
        if self.__scale == None:            self.__scale =  []
        self.__scale +=  [scale]
        return self
    def removeScale(self, scale):
        self.__scale = [x for x in self.__scale if x not in scale]
        return self.__scale
    def getScale(self, scale = [1, 1, 1]):
        return self.__scale
    def scale_changed(self, scale = [1, 1, 1]):
        return self.__scale
    @property
    def scaleOrientation(self):
        return self.__scaleOrientation
    @scaleOrientation.setter
    def scaleOrientation(self, value = [0, 0, 1, 0]):
        self.__scaleOrientation = [value]
    def setScaleOrientation(self, scaleOrientation = [0, 0, 1, 0]):
        self.__scaleOrientation = [scaleOrientation]
        return self
    def addScaleOrientation(self, scaleOrientation = [0, 0, 1, 0]):
        if self.__scaleOrientation == None:            self.__scaleOrientation =  []
        self.__scaleOrientation +=  [scaleOrientation]
        return self
    def removeScaleOrientation(self, scaleOrientation):
        self.__scaleOrientation = [x for x in self.__scaleOrientation if x not in scaleOrientation]
        return self.__scaleOrientation
    def getScaleOrientation(self, scaleOrientation = [0, 0, 1, 0]):
        return self.__scaleOrientation
    def scaleOrientation_changed(self, scaleOrientation = [0, 0, 1, 0]):
        return self.__scaleOrientation
    @property
    def segments(self):
        return self.__segments
    @segments.setter
    def segments(self, value = None):
        self.__segments = [value]
    def setSegments(self, segments = None):
        self.__segments = [segments]
        return self
    def addSegments(self, segments = None):
        if self.__segments == None:            self.__segments =  []
        self.__segments +=  [segments]
        return self
    def removeSegments(self, segments):
        self.__segments = [x for x in self.__segments if x not in segments]
        return self.__segments
    def getSegments(self, segments = None):
        return self.__segments
    def segments_changed(self, segments = None):
        return self.__segments
    @property
    def sites(self):
        return self.__sites
    @sites.setter
    def sites(self, value = None):
        self.__sites = [value]
    def setSites(self, sites = None):
        self.__sites = [sites]
        return self
    def addSites(self, sites = None):
        if self.__sites == None:            self.__sites =  []
        self.__sites +=  [sites]
        return self
    def removeSites(self, sites):
        self.__sites = [x for x in self.__sites if x not in sites]
        return self.__sites
    def getSites(self, sites = None):
        return self.__sites
    def sites_changed(self, sites = None):
        return self.__sites
    @property
    def skeletalConfiguration(self):
        return self.__skeletalConfiguration
    @skeletalConfiguration.setter
    def skeletalConfiguration(self, value = "BASIC"):
        self.__skeletalConfiguration = [value]
    def setSkeletalConfiguration(self, skeletalConfiguration = "BASIC"):
        self.__skeletalConfiguration = [skeletalConfiguration]
        return self
    def addSkeletalConfiguration(self, skeletalConfiguration = "BASIC"):
        if self.__skeletalConfiguration == None:            self.__skeletalConfiguration =  []
        self.__skeletalConfiguration +=  [skeletalConfiguration]
        return self
    def removeSkeletalConfiguration(self, skeletalConfiguration):
        self.__skeletalConfiguration = [x for x in self.__skeletalConfiguration if x not in skeletalConfiguration]
        return self.__skeletalConfiguration
    def getSkeletalConfiguration(self, skeletalConfiguration = "BASIC"):
        return self.__skeletalConfiguration
    def skeletalConfiguration_changed(self, skeletalConfiguration = "BASIC"):
        return self.__skeletalConfiguration
    @property
    def skeleton(self):
        return self.__skeleton
    @skeleton.setter
    def skeleton(self, value = None):
        self.__skeleton = [value]
    def setSkeleton(self, skeleton = None):
        self.__skeleton = [skeleton]
        return self
    def addSkeleton(self, skeleton = None):
        if self.__skeleton == None:            self.__skeleton =  []
        self.__skeleton +=  [skeleton]
        return self
    def removeSkeleton(self, skeleton):
        self.__skeleton = [x for x in self.__skeleton if x not in skeleton]
        return self.__skeleton
    def getSkeleton(self, skeleton = None):
        return self.__skeleton
    def skeleton_changed(self, skeleton = None):
        return self.__skeleton
    @property
    def skin(self):
        return self.__skin
    @skin.setter
    def skin(self, value = None):
        self.__skin = [value]
    def setSkin(self, skin = None):
        self.__skin = [skin]
        return self
    def addSkin(self, skin = None):
        if self.__skin == None:            self.__skin =  []
        self.__skin +=  [skin]
        return self
    def removeSkin(self, skin):
        self.__skin = [x for x in self.__skin if x not in skin]
        return self.__skin
    def getSkin(self, skin = None):
        return self.__skin
    def skin_changed(self, skin = None):
        return self.__skin
    @property
    def skinBindingCoords(self):
        return self.__skinBindingCoords
    @skinBindingCoords.setter
    def skinBindingCoords(self, value = None):
        self.__skinBindingCoords = [value]
    def setSkinBindingCoords(self, skinBindingCoords = None):
        self.__skinBindingCoords = [skinBindingCoords]
        return self
    def addSkinBindingCoords(self, skinBindingCoords = None):
        if self.__skinBindingCoords == None:            self.__skinBindingCoords =  []
        self.__skinBindingCoords +=  [skinBindingCoords]
        return self
    def removeSkinBindingCoords(self, skinBindingCoords):
        self.__skinBindingCoords = [x for x in self.__skinBindingCoords if x not in skinBindingCoords]
        return self.__skinBindingCoords
    def getSkinBindingCoords(self, skinBindingCoords = None):
        return self.__skinBindingCoords
    def skinBindingCoords_changed(self, skinBindingCoords = None):
        return self.__skinBindingCoords
    @property
    def skinBindingNormals(self):
        return self.__skinBindingNormals
    @skinBindingNormals.setter
    def skinBindingNormals(self, value = None):
        self.__skinBindingNormals = [value]
    def setSkinBindingNormals(self, skinBindingNormals = None):
        self.__skinBindingNormals = [skinBindingNormals]
        return self
    def addSkinBindingNormals(self, skinBindingNormals = None):
        if self.__skinBindingNormals == None:            self.__skinBindingNormals =  []
        self.__skinBindingNormals +=  [skinBindingNormals]
        return self
    def removeSkinBindingNormals(self, skinBindingNormals):
        self.__skinBindingNormals = [x for x in self.__skinBindingNormals if x not in skinBindingNormals]
        return self.__skinBindingNormals
    def getSkinBindingNormals(self, skinBindingNormals = None):
        return self.__skinBindingNormals
    def skinBindingNormals_changed(self, skinBindingNormals = None):
        return self.__skinBindingNormals
    @property
    def skinCoord(self):
        return self.__skinCoord
    @skinCoord.setter
    def skinCoord(self, value = None):
        self.__skinCoord = [value]
    def setSkinCoord(self, skinCoord = None):
        self.__skinCoord = [skinCoord]
        return self
    def addSkinCoord(self, skinCoord = None):
        if self.__skinCoord == None:            self.__skinCoord =  []
        self.__skinCoord +=  [skinCoord]
        return self
    def removeSkinCoord(self, skinCoord):
        self.__skinCoord = [x for x in self.__skinCoord if x not in skinCoord]
        return self.__skinCoord
    def getSkinCoord(self, skinCoord = None):
        return self.__skinCoord
    def skinCoord_changed(self, skinCoord = None):
        return self.__skinCoord
    @property
    def skinNormal(self):
        return self.__skinNormal
    @skinNormal.setter
    def skinNormal(self, value = None):
        self.__skinNormal = [value]
    def setSkinNormal(self, skinNormal = None):
        self.__skinNormal = [skinNormal]
        return self
    def addSkinNormal(self, skinNormal = None):
        if self.__skinNormal == None:            self.__skinNormal =  []
        self.__skinNormal +=  [skinNormal]
        return self
    def removeSkinNormal(self, skinNormal):
        self.__skinNormal = [x for x in self.__skinNormal if x not in skinNormal]
        return self.__skinNormal
    def getSkinNormal(self, skinNormal = None):
        return self.__skinNormal
    def skinNormal_changed(self, skinNormal = None):
        return self.__skinNormal
    @property
    def translation(self):
        return self.__translation
    @translation.setter
    def translation(self, value = [0, 0, 0]):
        self.__translation = [value]
    def setTranslation(self, translation = [0, 0, 0]):
        self.__translation = [translation]
        return self
    def addTranslation(self, translation = [0, 0, 0]):
        if self.__translation == None:            self.__translation =  []
        self.__translation +=  [translation]
        return self
    def removeTranslation(self, translation):
        self.__translation = [x for x in self.__translation if x not in translation]
        return self.__translation
    def getTranslation(self, translation = [0, 0, 0]):
        return self.__translation
    def translation_changed(self, translation = [0, 0, 0]):
        return self.__translation
    @property
    def version(self):
        return self.__version
    @version.setter
    def version(self, value = "2.0"):
        if '1.0' == value:
            pass
        elif '1.1' == value:
            pass
        elif '2.0' == value:
            pass
        else:
            return None
        self.__version = [value]
    def setVersion(self, version = "2.0"):
        if '1.0' == version:
            pass
        elif '1.1' == version:
            pass
        elif '2.0' == version:
            pass
        else:
            return None
        self.__version = [version]
        return self
    def addVersion(self, version = "2.0"):
        if '1.0' == version:
            pass
        elif '1.1' == version:
            pass
        elif '2.0' == version:
            pass
        else:
            return None
        if self.__version == None:            self.__version =  []
        self.__version +=  [version]
        return self
    def removeVersion(self, version):
        self.__version = [x for x in self.__version if x not in version]
        return self.__version
    def getVersion(self, version = "2.0"):
        return self.__version
    def version_changed(self, version = "2.0"):
        return self.__version
    @property
    def viewpoints(self):
        return self.__viewpoints
    @viewpoints.setter
    def viewpoints(self, value = None):
        self.__viewpoints = [value]
    def setViewpoints(self, viewpoints = None):
        self.__viewpoints = [viewpoints]
        return self
    def addViewpoints(self, viewpoints = None):
        if self.__viewpoints == None:            self.__viewpoints =  []
        self.__viewpoints +=  [viewpoints]
        return self
    def removeViewpoints(self, viewpoints):
        self.__viewpoints = [x for x in self.__viewpoints if x not in viewpoints]
        return self.__viewpoints
    def getViewpoints(self, viewpoints = None):
        return self.__viewpoints
    def viewpoints_changed(self, viewpoints = None):
        return self.__viewpoints
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<HAnimHumanoid'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__center is not None:
            if isinstance(self.__center, six.string_types):
                str += ' center="'+self.__center+'"'
            else:
                str += ' center="'+self.__center[0]+'"'
        if self.__description is not None:
            if isinstance(self.__description, six.string_types):
                str += ' description="'+self.__description+'"'
            else:
                str += ' description="'+self.__description[0]+'"'
        if self.__info is not None:
            if isinstance(self.__info, six.string_types):
                str += ' info="'+self.__info+'"'
            else:
                str += ' info="'+self.__info[0]+'"'
        if self.__jointBindingPositions is not None:
            if isinstance(self.__jointBindingPositions, six.string_types):
                str += ' jointBindingPositions="'+self.__jointBindingPositions+'"'
            else:
                str += ' jointBindingPositions="'+self.__jointBindingPositions[0]+'"'
        if self.__jointBindingRotations is not None:
            if isinstance(self.__jointBindingRotations, six.string_types):
                str += ' jointBindingRotations="'+self.__jointBindingRotations+'"'
            else:
                str += ' jointBindingRotations="'+self.__jointBindingRotations[0]+'"'
        if self.__jointBindingScales is not None:
            if isinstance(self.__jointBindingScales, six.string_types):
                str += ' jointBindingScales="'+self.__jointBindingScales+'"'
            else:
                str += ' jointBindingScales="'+self.__jointBindingScales[0]+'"'
        if self.__loa is not None:
            if isinstance(self.__loa, six.string_types):
                str += ' loa="'+self.__loa+'"'
            else:
                str += ' loa="'+self.__loa[0]+'"'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        if self.__rotation is not None:
            if isinstance(self.__rotation, six.string_types):
                str += ' rotation="'+self.__rotation+'"'
            else:
                str += ' rotation="'+self.__rotation[0]+'"'
        if self.__scale is not None:
            if isinstance(self.__scale, six.string_types):
                str += ' scale="'+self.__scale+'"'
            else:
                str += ' scale="'+self.__scale[0]+'"'
        if self.__scaleOrientation is not None:
            if isinstance(self.__scaleOrientation, six.string_types):
                str += ' scaleOrientation="'+self.__scaleOrientation+'"'
            else:
                str += ' scaleOrientation="'+self.__scaleOrientation[0]+'"'
        if self.__skeletalConfiguration is not None:
            if isinstance(self.__skeletalConfiguration, six.string_types):
                str += ' skeletalConfiguration="'+self.__skeletalConfiguration+'"'
            else:
                str += ' skeletalConfiguration="'+self.__skeletalConfiguration[0]+'"'
        if self.__translation is not None:
            if isinstance(self.__translation, six.string_types):
                str += ' translation="'+self.__translation+'"'
            else:
                str += ' translation="'+self.__translation[0]+'"'
        if self.__version is not None:
            if isinstance(self.__version, six.string_types):
                str += ' version="'+self.__version+'"'
            else:
                str += ' version="'+self.__version[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<joints'
        if self.__joints is not None:
           for s in self.__joints:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__joints is not None:
           for s in self.__joints:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</joints>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<motions'
        if self.__motions is not None:
           for s in self.__motions:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__motions is not None:
           for s in self.__motions:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</motions>'
        str += '<segments'
        if self.__segments is not None:
           for s in self.__segments:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__segments is not None:
           for s in self.__segments:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</segments>'
        str += '<sites'
        if self.__sites is not None:
           for s in self.__sites:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__sites is not None:
           for s in self.__sites:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</sites>'
        str += '<skeleton'
        if self.__skeleton is not None:
           for s in self.__skeleton:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__skeleton is not None:
           for s in self.__skeleton:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</skeleton>'
        str += '<skin'
        if self.__skin is not None:
           for s in self.__skin:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__skin is not None:
           for s in self.__skin:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</skin>'
        str += '<skinBindingCoords'
        if self.__skinBindingCoords is not None:
           for s in self.__skinBindingCoords:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__skinBindingCoords is not None:
           for s in self.__skinBindingCoords:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</skinBindingCoords>'
        str += '<skinBindingNormals'
        if self.__skinBindingNormals is not None:
           for s in self.__skinBindingNormals:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__skinBindingNormals is not None:
           for s in self.__skinBindingNormals:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</skinBindingNormals>'
        str += '<skinCoord'
        if self.__skinCoord is not None:
           for s in self.__skinCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__skinCoord is not None:
           for s in self.__skinCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</skinCoord>'
        str += '<skinNormal'
        if self.__skinNormal is not None:
           for s in self.__skinNormal:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__skinNormal is not None:
           for s in self.__skinNormal:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</skinNormal>'
        str += '<viewpoints'
        if self.__viewpoints is not None:
           for s in self.__viewpoints:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__viewpoints is not None:
           for s in self.__viewpoints:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</viewpoints>'
        str += '</HAnimHumanoid>'
        return str


class HAnimJoint(X3DBoundedObject, X3DChildNode):
    def __init__(self, **kwargs):
        super(HAnimJoint, self).__init__(**kwargs)
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        center  = kwargs.pop("center", [0, 0, 0])
        self.__center = center
        children  = kwargs.pop("children", None)
        self.__children = children
        description  = kwargs.pop("description", None)
        self.__description = description
        displacers  = kwargs.pop("displacers", None)
        self.__displacers = displacers
        limitOrientation  = kwargs.pop("limitOrientation", [0, 0, 1, 0])
        self.__limitOrientation = limitOrientation
        llimit  = kwargs.pop("llimit", [0, 0, 0])
        self.__llimit = llimit
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        name  = kwargs.pop("name", None)
        self.__name = name
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        rotation  = kwargs.pop("rotation", [0, 0, 1, 0])
        self.__rotation = rotation
        scale  = kwargs.pop("scale", [1, 1, 1])
        if scale == None or len(scale) <= 0 or min(scale)  <=  0:
            return None
        self.__scale = scale
        scaleOrientation  = kwargs.pop("scaleOrientation", [0, 0, 1, 0])
        self.__scaleOrientation = scaleOrientation
        skinCoordIndex  = kwargs.pop("skinCoordIndex", None)
        if skinCoordIndex == None or len(skinCoordIndex) <= 0 or min(skinCoordIndex)  <  0:
            return None
        self.__skinCoordIndex = skinCoordIndex
        skinCoordWeight  = kwargs.pop("skinCoordWeight", None)
        self.__skinCoordWeight = skinCoordWeight
        stiffness  = kwargs.pop("stiffness", [1, 1, 1])
        if stiffness == None or len(stiffness) <= 0 or min(stiffness)  <  0:
            return None
        if stiffness == None or len(stiffness) <= 0 or max(stiffness)  >  1:
            return None
        self.__stiffness = stiffness
        translation  = kwargs.pop("translation", [0, 0, 0])
        self.__translation = translation
        ulimit  = kwargs.pop("ulimit", [0, 0, 0])
        self.__ulimit = ulimit
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    def addChildren(self, Children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [Children]
        return self
    @property
    def center(self):
        return self.__center
    @center.setter
    def center(self, value = [0, 0, 0]):
        self.__center = [value]
    def setCenter(self, center = [0, 0, 0]):
        self.__center = [center]
        return self
    def addCenter(self, center = [0, 0, 0]):
        if self.__center == None:            self.__center =  []
        self.__center +=  [center]
        return self
    def removeCenter(self, center):
        self.__center = [x for x in self.__center if x not in center]
        return self.__center
    def getCenter(self, center = [0, 0, 0]):
        return self.__center
    def center_changed(self, center = [0, 0, 0]):
        return self.__center
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    @property
    def description(self):
        return self.__description
    @description.setter
    def description(self, value = None):
        self.__description = [value]
    def setDescription(self, description = None):
        self.__description = [description]
        return self
    def addDescription(self, description = None):
        if self.__description == None:            self.__description =  []
        self.__description +=  [description]
        return self
    def removeDescription(self, description):
        self.__description = [x for x in self.__description if x not in description]
        return self.__description
    def getDescription(self, description = None):
        return self.__description
    def description_changed(self, description = None):
        return self.__description
    @property
    def displacers(self):
        return self.__displacers
    @displacers.setter
    def displacers(self, value = None):
        self.__displacers = [value]
    def setDisplacers(self, displacers = None):
        self.__displacers = [displacers]
        return self
    def addDisplacers(self, displacers = None):
        if self.__displacers == None:            self.__displacers =  []
        self.__displacers +=  [displacers]
        return self
    def removeDisplacers(self, displacers):
        self.__displacers = [x for x in self.__displacers if x not in displacers]
        return self.__displacers
    def getDisplacers(self, displacers = None):
        return self.__displacers
    def displacers_changed(self, displacers = None):
        return self.__displacers
    @property
    def limitOrientation(self):
        return self.__limitOrientation
    @limitOrientation.setter
    def limitOrientation(self, value = [0, 0, 1, 0]):
        self.__limitOrientation = [value]
    def setLimitOrientation(self, limitOrientation = [0, 0, 1, 0]):
        self.__limitOrientation = [limitOrientation]
        return self
    def addLimitOrientation(self, limitOrientation = [0, 0, 1, 0]):
        if self.__limitOrientation == None:            self.__limitOrientation =  []
        self.__limitOrientation +=  [limitOrientation]
        return self
    def removeLimitOrientation(self, limitOrientation):
        self.__limitOrientation = [x for x in self.__limitOrientation if x not in limitOrientation]
        return self.__limitOrientation
    def getLimitOrientation(self, limitOrientation = [0, 0, 1, 0]):
        return self.__limitOrientation
    def limitOrientation_changed(self, limitOrientation = [0, 0, 1, 0]):
        return self.__limitOrientation
    @property
    def llimit(self):
        return self.__llimit
    @llimit.setter
    def llimit(self, value = [0, 0, 0]):
        self.__llimit = [value]
    def setLlimit(self, llimit = [0, 0, 0]):
        self.__llimit = [llimit]
        return self
    def addLlimit(self, llimit = [0, 0, 0]):
        if self.__llimit == None:            self.__llimit =  []
        self.__llimit +=  [llimit]
        return self
    def removeLlimit(self, llimit):
        self.__llimit = [x for x in self.__llimit if x not in llimit]
        return self.__llimit
    def getLlimit(self, llimit = [0, 0, 0]):
        return self.__llimit
    def llimit_changed(self, llimit = [0, 0, 0]):
        return self.__llimit
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        self.__name = [value]
    def setName(self, name = None):
        self.__name = [name]
        return self
    def addName(self, name = None):
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    @property
    def rotation(self):
        return self.__rotation
    @rotation.setter
    def rotation(self, value = [0, 0, 1, 0]):
        self.__rotation = [value]
    def setRotation(self, rotation = [0, 0, 1, 0]):
        self.__rotation = [rotation]
        return self
    def addRotation(self, rotation = [0, 0, 1, 0]):
        if self.__rotation == None:            self.__rotation =  []
        self.__rotation +=  [rotation]
        return self
    def removeRotation(self, rotation):
        self.__rotation = [x for x in self.__rotation if x not in rotation]
        return self.__rotation
    def getRotation(self, rotation = [0, 0, 1, 0]):
        return self.__rotation
    def rotation_changed(self, rotation = [0, 0, 1, 0]):
        return self.__rotation
    @property
    def scale(self):
        return self.__scale
    @scale.setter
    def scale(self, value = [1, 1, 1]):
        if value == None or len(value) <= 0 or min(value)  <=  0:
            return None
        self.__scale = [value]
    def setScale(self, scale = [1, 1, 1]):
        if scale == None or len(scale) <= 0 or min(scale)  <=  0:
            return None
        self.__scale = [scale]
        return self
    def addScale(self, scale = [1, 1, 1]):
        if scale == None or len(scale) <= 0 or min(scale)  <=  0:
            return None
        if self.__scale == None:            self.__scale =  []
        self.__scale +=  [scale]
        return self
    def removeScale(self, scale):
        self.__scale = [x for x in self.__scale if x not in scale]
        return self.__scale
    def getScale(self, scale = [1, 1, 1]):
        return self.__scale
    def scale_changed(self, scale = [1, 1, 1]):
        return self.__scale
    @property
    def scaleOrientation(self):
        return self.__scaleOrientation
    @scaleOrientation.setter
    def scaleOrientation(self, value = [0, 0, 1, 0]):
        self.__scaleOrientation = [value]
    def setScaleOrientation(self, scaleOrientation = [0, 0, 1, 0]):
        self.__scaleOrientation = [scaleOrientation]
        return self
    def addScaleOrientation(self, scaleOrientation = [0, 0, 1, 0]):
        if self.__scaleOrientation == None:            self.__scaleOrientation =  []
        self.__scaleOrientation +=  [scaleOrientation]
        return self
    def removeScaleOrientation(self, scaleOrientation):
        self.__scaleOrientation = [x for x in self.__scaleOrientation if x not in scaleOrientation]
        return self.__scaleOrientation
    def getScaleOrientation(self, scaleOrientation = [0, 0, 1, 0]):
        return self.__scaleOrientation
    def scaleOrientation_changed(self, scaleOrientation = [0, 0, 1, 0]):
        return self.__scaleOrientation
    @property
    def skinCoordIndex(self):
        return self.__skinCoordIndex
    @skinCoordIndex.setter
    def skinCoordIndex(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        self.__skinCoordIndex = [value]
    def setSkinCoordIndex(self, skinCoordIndex = None):
        if skinCoordIndex == None or len(skinCoordIndex) <= 0 or min(skinCoordIndex)  <  0:
            return None
        self.__skinCoordIndex = [skinCoordIndex]
        return self
    def addSkinCoordIndex(self, skinCoordIndex = None):
        if skinCoordIndex == None or len(skinCoordIndex) <= 0 or min(skinCoordIndex)  <  0:
            return None
        if self.__skinCoordIndex == None:            self.__skinCoordIndex =  []
        self.__skinCoordIndex +=  [skinCoordIndex]
        return self
    def removeSkinCoordIndex(self, skinCoordIndex):
        self.__skinCoordIndex = [x for x in self.__skinCoordIndex if x not in skinCoordIndex]
        return self.__skinCoordIndex
    def getSkinCoordIndex(self, skinCoordIndex = None):
        return self.__skinCoordIndex
    def skinCoordIndex_changed(self, skinCoordIndex = None):
        return self.__skinCoordIndex
    @property
    def skinCoordWeight(self):
        return self.__skinCoordWeight
    @skinCoordWeight.setter
    def skinCoordWeight(self, value = None):
        self.__skinCoordWeight = [value]
    def setSkinCoordWeight(self, skinCoordWeight = None):
        self.__skinCoordWeight = [skinCoordWeight]
        return self
    def addSkinCoordWeight(self, skinCoordWeight = None):
        if self.__skinCoordWeight == None:            self.__skinCoordWeight =  []
        self.__skinCoordWeight +=  [skinCoordWeight]
        return self
    def removeSkinCoordWeight(self, skinCoordWeight):
        self.__skinCoordWeight = [x for x in self.__skinCoordWeight if x not in skinCoordWeight]
        return self.__skinCoordWeight
    def getSkinCoordWeight(self, skinCoordWeight = None):
        return self.__skinCoordWeight
    def skinCoordWeight_changed(self, skinCoordWeight = None):
        return self.__skinCoordWeight
    @property
    def stiffness(self):
        return self.__stiffness
    @stiffness.setter
    def stiffness(self, value = [1, 1, 1]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__stiffness = [value]
    def setStiffness(self, stiffness = [1, 1, 1]):
        if stiffness == None or len(stiffness) <= 0 or min(stiffness)  <  0:
            return None
        if stiffness == None or len(stiffness) <= 0 or max(stiffness)  >  1:
            return None
        self.__stiffness = [stiffness]
        return self
    def addStiffness(self, stiffness = [1, 1, 1]):
        if stiffness == None or len(stiffness) <= 0 or min(stiffness)  <  0:
            return None
        if stiffness == None or len(stiffness) <= 0 or max(stiffness)  >  1:
            return None
        if self.__stiffness == None:            self.__stiffness =  []
        self.__stiffness +=  [stiffness]
        return self
    def removeStiffness(self, stiffness):
        self.__stiffness = [x for x in self.__stiffness if x not in stiffness]
        return self.__stiffness
    def getStiffness(self, stiffness = [1, 1, 1]):
        return self.__stiffness
    def stiffness_changed(self, stiffness = [1, 1, 1]):
        return self.__stiffness
    @property
    def translation(self):
        return self.__translation
    @translation.setter
    def translation(self, value = [0, 0, 0]):
        self.__translation = [value]
    def setTranslation(self, translation = [0, 0, 0]):
        self.__translation = [translation]
        return self
    def addTranslation(self, translation = [0, 0, 0]):
        if self.__translation == None:            self.__translation =  []
        self.__translation +=  [translation]
        return self
    def removeTranslation(self, translation):
        self.__translation = [x for x in self.__translation if x not in translation]
        return self.__translation
    def getTranslation(self, translation = [0, 0, 0]):
        return self.__translation
    def translation_changed(self, translation = [0, 0, 0]):
        return self.__translation
    @property
    def ulimit(self):
        return self.__ulimit
    @ulimit.setter
    def ulimit(self, value = [0, 0, 0]):
        self.__ulimit = [value]
    def setUlimit(self, ulimit = [0, 0, 0]):
        self.__ulimit = [ulimit]
        return self
    def addUlimit(self, ulimit = [0, 0, 0]):
        if self.__ulimit == None:            self.__ulimit =  []
        self.__ulimit +=  [ulimit]
        return self
    def removeUlimit(self, ulimit):
        self.__ulimit = [x for x in self.__ulimit if x not in ulimit]
        return self.__ulimit
    def getUlimit(self, ulimit = [0, 0, 0]):
        return self.__ulimit
    def ulimit_changed(self, ulimit = [0, 0, 0]):
        return self.__ulimit
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<HAnimJoint'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__center is not None:
            if isinstance(self.__center, six.string_types):
                str += ' center="'+self.__center+'"'
            else:
                str += ' center="'+self.__center[0]+'"'
        if self.__description is not None:
            if isinstance(self.__description, six.string_types):
                str += ' description="'+self.__description+'"'
            else:
                str += ' description="'+self.__description[0]+'"'
        if self.__limitOrientation is not None:
            if isinstance(self.__limitOrientation, six.string_types):
                str += ' limitOrientation="'+self.__limitOrientation+'"'
            else:
                str += ' limitOrientation="'+self.__limitOrientation[0]+'"'
        if self.__llimit is not None:
            if isinstance(self.__llimit, six.string_types):
                str += ' llimit="'+self.__llimit+'"'
            else:
                str += ' llimit="'+self.__llimit[0]+'"'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        if self.__rotation is not None:
            if isinstance(self.__rotation, six.string_types):
                str += ' rotation="'+self.__rotation+'"'
            else:
                str += ' rotation="'+self.__rotation[0]+'"'
        if self.__scale is not None:
            if isinstance(self.__scale, six.string_types):
                str += ' scale="'+self.__scale+'"'
            else:
                str += ' scale="'+self.__scale[0]+'"'
        if self.__scaleOrientation is not None:
            if isinstance(self.__scaleOrientation, six.string_types):
                str += ' scaleOrientation="'+self.__scaleOrientation+'"'
            else:
                str += ' scaleOrientation="'+self.__scaleOrientation[0]+'"'
        if self.__skinCoordIndex is not None:
            if isinstance(self.__skinCoordIndex, six.string_types):
                str += ' skinCoordIndex="'+self.__skinCoordIndex+'"'
            else:
                str += ' skinCoordIndex="'+self.__skinCoordIndex[0]+'"'
        if self.__skinCoordWeight is not None:
            if isinstance(self.__skinCoordWeight, six.string_types):
                str += ' skinCoordWeight="'+self.__skinCoordWeight+'"'
            else:
                str += ' skinCoordWeight="'+self.__skinCoordWeight[0]+'"'
        if self.__stiffness is not None:
            if isinstance(self.__stiffness, six.string_types):
                str += ' stiffness="'+self.__stiffness+'"'
            else:
                str += ' stiffness="'+self.__stiffness[0]+'"'
        if self.__translation is not None:
            if isinstance(self.__translation, six.string_types):
                str += ' translation="'+self.__translation+'"'
            else:
                str += ' translation="'+self.__translation[0]+'"'
        if self.__ulimit is not None:
            if isinstance(self.__ulimit, six.string_types):
                str += ' ulimit="'+self.__ulimit+'"'
            else:
                str += ' ulimit="'+self.__ulimit[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '<displacers'
        if self.__displacers is not None:
           for s in self.__displacers:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__displacers is not None:
           for s in self.__displacers:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</displacers>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '</HAnimJoint>'
        return str


class HAnimMotion(X3DChildNode):
    def __init__(self, **kwargs):
        super(HAnimMotion, self).__init__(**kwargs)
        channels  = kwargs.pop("channels", None)
        self.__channels = channels
        channelsEnabled  = kwargs.pop("channelsEnabled", None)
        self.__channelsEnabled = channelsEnabled
        cycleTime  = kwargs.pop("cycleTime", None)
        if cycleTime == None or cycleTime  <  0:
            return None
        self.__cycleTime = cycleTime
        description  = kwargs.pop("description", None)
        self.__description = description
        elapsedTime  = kwargs.pop("elapsedTime", None)
        if elapsedTime == None or elapsedTime  <  0:
            return None
        self.__elapsedTime = elapsedTime
        enabled  = kwargs.pop("enabled", False)
        self.__enabled = enabled
        endFrame  = kwargs.pop("endFrame", -1)
        if endFrame == None or endFrame  <  -1:
            return None
        self.__endFrame = endFrame
        frameCount  = kwargs.pop("frameCount", None)
        if frameCount == None or frameCount  <  0:
            return None
        self.__frameCount = frameCount
        frameDuration  = kwargs.pop("frameDuration", 0.1)
        if frameDuration == None or frameDuration  <=  0:
            return None
        self.__frameDuration = frameDuration
        frameIncrement  = kwargs.pop("frameIncrement", 1)
        self.__frameIncrement = frameIncrement
        frameIndex  = kwargs.pop("frameIndex", 0)
        if frameIndex == None or frameIndex  <  0:
            return None
        self.__frameIndex = frameIndex
        joints  = kwargs.pop("joints", None)
        self.__joints = joints
        loa  = kwargs.pop("loa", -1)
        if loa == None or loa  <  -1:
            return None
        if loa == None or loa  >  4:
            return None
        self.__loa = loa
        loop  = kwargs.pop("loop", False)
        self.__loop = loop
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        startFrame  = kwargs.pop("startFrame", 0)
        if startFrame == None or startFrame  <  0:
            return None
        self.__startFrame = startFrame
        values  = kwargs.pop("values", None)
        self.__values = values
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def channels(self):
        return self.__channels
    @channels.setter
    def channels(self, value = None):
        self.__channels = [value]
    def setChannels(self, channels = None):
        self.__channels = [channels]
        return self
    def addChannels(self, channels = None):
        if self.__channels == None:            self.__channels =  []
        self.__channels +=  [channels]
        return self
    def removeChannels(self, channels):
        self.__channels = [x for x in self.__channels if x not in channels]
        return self.__channels
    def getChannels(self, channels = None):
        return self.__channels
    def channels_changed(self, channels = None):
        return self.__channels
    @property
    def channelsEnabled(self):
        return self.__channelsEnabled
    @channelsEnabled.setter
    def channelsEnabled(self, value = None):
        self.__channelsEnabled = [value]
    def setChannelsEnabled(self, channelsEnabled = None):
        self.__channelsEnabled = [channelsEnabled]
        return self
    def addChannelsEnabled(self, channelsEnabled = None):
        if self.__channelsEnabled == None:            self.__channelsEnabled =  []
        self.__channelsEnabled +=  [channelsEnabled]
        return self
    def removeChannelsEnabled(self, channelsEnabled):
        self.__channelsEnabled = [x for x in self.__channelsEnabled if x not in channelsEnabled]
        return self.__channelsEnabled
    def getChannelsEnabled(self, channelsEnabled = None):
        return self.__channelsEnabled
    def channelsEnabled_changed(self, channelsEnabled = None):
        return self.__channelsEnabled
    def removeCycleTime(self, cycleTime):
        self.__cycleTime = [x for x in self.__cycleTime if x not in cycleTime]
        return self.__cycleTime
    def getCycleTime(self, cycleTime = None):
        return self.__cycleTime
    def cycleTime_changed(self, cycleTime = None):
        return self.__cycleTime
    @property
    def description(self):
        return self.__description
    @description.setter
    def description(self, value = None):
        self.__description = [value]
    def setDescription(self, description = None):
        self.__description = [description]
        return self
    def addDescription(self, description = None):
        if self.__description == None:            self.__description =  []
        self.__description +=  [description]
        return self
    def removeDescription(self, description):
        self.__description = [x for x in self.__description if x not in description]
        return self.__description
    def getDescription(self, description = None):
        return self.__description
    def description_changed(self, description = None):
        return self.__description
    def removeElapsedTime(self, elapsedTime):
        self.__elapsedTime = [x for x in self.__elapsedTime if x not in elapsedTime]
        return self.__elapsedTime
    def getElapsedTime(self, elapsedTime = None):
        return self.__elapsedTime
    def elapsedTime_changed(self, elapsedTime = None):
        return self.__elapsedTime
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = False):
        self.__enabled = [value]
    def setEnabled(self, enabled = False):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = False):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = False):
        return self.__enabled
    @property
    def endFrame(self):
        return self.__endFrame
    @endFrame.setter
    def endFrame(self, value = -1):
        if value == None or value  <  -1:
            return None
        self.__endFrame = [value]
    def setEndFrame(self, endFrame = -1):
        if endFrame == None or endFrame  <  -1:
            return None
        self.__endFrame = [endFrame]
        return self
    def addEndFrame(self, endFrame = -1):
        if endFrame == None or endFrame  <  -1:
            return None
        if self.__endFrame == None:            self.__endFrame =  []
        self.__endFrame +=  [endFrame]
        return self
    def removeEndFrame(self, endFrame):
        self.__endFrame = [x for x in self.__endFrame if x not in endFrame]
        return self.__endFrame
    def getEndFrame(self, endFrame = -1):
        return self.__endFrame
    def endFrame_changed(self, endFrame = -1):
        return self.__endFrame
    def removeFrameCount(self, frameCount):
        self.__frameCount = [x for x in self.__frameCount if x not in frameCount]
        return self.__frameCount
    def getFrameCount(self, frameCount = None):
        return self.__frameCount
    def frameCount_changed(self, frameCount = None):
        return self.__frameCount
    @property
    def frameDuration(self):
        return self.__frameDuration
    @frameDuration.setter
    def frameDuration(self, value = 0.1):
        if value == None or value  <=  0:
            return None
        self.__frameDuration = [value]
    def setFrameDuration(self, frameDuration = 0.1):
        if frameDuration == None or frameDuration  <=  0:
            return None
        self.__frameDuration = [frameDuration]
        return self
    def addFrameDuration(self, frameDuration = 0.1):
        if frameDuration == None or frameDuration  <=  0:
            return None
        if self.__frameDuration == None:            self.__frameDuration =  []
        self.__frameDuration +=  [frameDuration]
        return self
    def removeFrameDuration(self, frameDuration):
        self.__frameDuration = [x for x in self.__frameDuration if x not in frameDuration]
        return self.__frameDuration
    def getFrameDuration(self, frameDuration = 0.1):
        return self.__frameDuration
    def frameDuration_changed(self, frameDuration = 0.1):
        return self.__frameDuration
    @property
    def frameIncrement(self):
        return self.__frameIncrement
    @frameIncrement.setter
    def frameIncrement(self, value = 1):
        self.__frameIncrement = [value]
    def setFrameIncrement(self, frameIncrement = 1):
        self.__frameIncrement = [frameIncrement]
        return self
    def addFrameIncrement(self, frameIncrement = 1):
        if self.__frameIncrement == None:            self.__frameIncrement =  []
        self.__frameIncrement +=  [frameIncrement]
        return self
    def removeFrameIncrement(self, frameIncrement):
        self.__frameIncrement = [x for x in self.__frameIncrement if x not in frameIncrement]
        return self.__frameIncrement
    def getFrameIncrement(self, frameIncrement = 1):
        return self.__frameIncrement
    def frameIncrement_changed(self, frameIncrement = 1):
        return self.__frameIncrement
    @property
    def frameIndex(self):
        return self.__frameIndex
    @frameIndex.setter
    def frameIndex(self, value = 0):
        if value == None or value  <  0:
            return None
        self.__frameIndex = [value]
    def setFrameIndex(self, frameIndex = 0):
        if frameIndex == None or frameIndex  <  0:
            return None
        self.__frameIndex = [frameIndex]
        return self
    def addFrameIndex(self, frameIndex = 0):
        if frameIndex == None or frameIndex  <  0:
            return None
        if self.__frameIndex == None:            self.__frameIndex =  []
        self.__frameIndex +=  [frameIndex]
        return self
    def removeFrameIndex(self, frameIndex):
        self.__frameIndex = [x for x in self.__frameIndex if x not in frameIndex]
        return self.__frameIndex
    def getFrameIndex(self, frameIndex = 0):
        return self.__frameIndex
    def frameIndex_changed(self, frameIndex = 0):
        return self.__frameIndex
    @property
    def joints(self):
        return self.__joints
    @joints.setter
    def joints(self, value = None):
        self.__joints = [value]
    def setJoints(self, joints = None):
        self.__joints = [joints]
        return self
    def addJoints(self, joints = None):
        if self.__joints == None:            self.__joints =  []
        self.__joints +=  [joints]
        return self
    def removeJoints(self, joints):
        self.__joints = [x for x in self.__joints if x not in joints]
        return self.__joints
    def getJoints(self, joints = None):
        return self.__joints
    def joints_changed(self, joints = None):
        return self.__joints
    @property
    def loa(self):
        return self.__loa
    @loa.setter
    def loa(self, value = -1):
        if value == None or value  <  -1:
            return None
        if value == None or value  >  4:
            return None
        self.__loa = [value]
    def setLoa(self, loa = -1):
        if loa == None or loa  <  -1:
            return None
        if loa == None or loa  >  4:
            return None
        self.__loa = [loa]
        return self
    def addLoa(self, loa = -1):
        if loa == None or loa  <  -1:
            return None
        if loa == None or loa  >  4:
            return None
        if self.__loa == None:            self.__loa =  []
        self.__loa +=  [loa]
        return self
    def removeLoa(self, loa):
        self.__loa = [x for x in self.__loa if x not in loa]
        return self.__loa
    def getLoa(self, loa = -1):
        return self.__loa
    def loa_changed(self, loa = -1):
        return self.__loa
    @property
    def loop(self):
        return self.__loop
    @loop.setter
    def loop(self, value = False):
        self.__loop = [value]
    def setLoop(self, loop = False):
        self.__loop = [loop]
        return self
    def addLoop(self, loop = False):
        if self.__loop == None:            self.__loop =  []
        self.__loop +=  [loop]
        return self
    def removeLoop(self, loop):
        self.__loop = [x for x in self.__loop if x not in loop]
        return self.__loop
    def isLoop(self, loop = False):
        return self.__loop
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def startFrame(self):
        return self.__startFrame
    @startFrame.setter
    def startFrame(self, value = 0):
        if value == None or value  <  0:
            return None
        self.__startFrame = [value]
    def setStartFrame(self, startFrame = 0):
        if startFrame == None or startFrame  <  0:
            return None
        self.__startFrame = [startFrame]
        return self
    def addStartFrame(self, startFrame = 0):
        if startFrame == None or startFrame  <  0:
            return None
        if self.__startFrame == None:            self.__startFrame =  []
        self.__startFrame +=  [startFrame]
        return self
    def removeStartFrame(self, startFrame):
        self.__startFrame = [x for x in self.__startFrame if x not in startFrame]
        return self.__startFrame
    def getStartFrame(self, startFrame = 0):
        return self.__startFrame
    def startFrame_changed(self, startFrame = 0):
        return self.__startFrame
    @property
    def values(self):
        return self.__values
    @values.setter
    def values(self, value = None):
        self.__values = [value]
    def setValues(self, values = None):
        self.__values = [values]
        return self
    def addValues(self, values = None):
        if self.__values == None:            self.__values =  []
        self.__values +=  [values]
        return self
    def removeValues(self, values):
        self.__values = [x for x in self.__values if x not in values]
        return self.__values
    def getValues(self, values = None):
        return self.__values
    def values_changed(self, values = None):
        return self.__values
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<HAnimMotion'
        if self.__channels is not None:
            if isinstance(self.__channels, six.string_types):
                str += ' channels="'+self.__channels+'"'
            else:
                str += ' channels="'+self.__channels[0]+'"'
        if self.__channelsEnabled is not None:
            if isinstance(self.__channelsEnabled, six.string_types):
                str += ' channelsEnabled="'+self.__channelsEnabled+'"'
            else:
                str += ' channelsEnabled="'+self.__channelsEnabled[0]+'"'
        if self.__cycleTime is not None:
            if isinstance(self.__cycleTime, six.string_types):
                str += ' cycleTime="'+self.__cycleTime+'"'
            else:
                str += ' cycleTime="'+self.__cycleTime[0]+'"'
        if self.__description is not None:
            if isinstance(self.__description, six.string_types):
                str += ' description="'+self.__description+'"'
            else:
                str += ' description="'+self.__description[0]+'"'
        if self.__elapsedTime is not None:
            if isinstance(self.__elapsedTime, six.string_types):
                str += ' elapsedTime="'+self.__elapsedTime+'"'
            else:
                str += ' elapsedTime="'+self.__elapsedTime[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__endFrame is not None:
            if isinstance(self.__endFrame, six.string_types):
                str += ' endFrame="'+self.__endFrame+'"'
            else:
                str += ' endFrame="'+self.__endFrame[0]+'"'
        if self.__frameCount is not None:
            if isinstance(self.__frameCount, six.string_types):
                str += ' frameCount="'+self.__frameCount+'"'
            else:
                str += ' frameCount="'+self.__frameCount[0]+'"'
        if self.__frameDuration is not None:
            if isinstance(self.__frameDuration, six.string_types):
                str += ' frameDuration="'+self.__frameDuration+'"'
            else:
                str += ' frameDuration="'+self.__frameDuration[0]+'"'
        if self.__frameIncrement is not None:
            if isinstance(self.__frameIncrement, six.string_types):
                str += ' frameIncrement="'+self.__frameIncrement+'"'
            else:
                str += ' frameIncrement="'+self.__frameIncrement[0]+'"'
        if self.__frameIndex is not None:
            if isinstance(self.__frameIndex, six.string_types):
                str += ' frameIndex="'+self.__frameIndex+'"'
            else:
                str += ' frameIndex="'+self.__frameIndex[0]+'"'
        if self.__joints is not None:
            if isinstance(self.__joints, six.string_types):
                str += ' joints="'+self.__joints+'"'
            else:
                str += ' joints="'+self.__joints[0]+'"'
        if self.__loa is not None:
            if isinstance(self.__loa, six.string_types):
                str += ' loa="'+self.__loa+'"'
            else:
                str += ' loa="'+self.__loa[0]+'"'
        if self.__loop is not None:
            if isinstance(self.__loop, six.string_types):
                str += ' loop="'+self.__loop+'"'
            else:
                str += ' loop="'+self.__loop[0]+'"'
        if self.__startFrame is not None:
            if isinstance(self.__startFrame, six.string_types):
                str += ' startFrame="'+self.__startFrame+'"'
            else:
                str += ' startFrame="'+self.__startFrame[0]+'"'
        if self.__values is not None:
            if isinstance(self.__values, six.string_types):
                str += ' values="'+self.__values+'"'
            else:
                str += ' values="'+self.__values[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</HAnimMotion>'
        return str


class HAnimSegment(X3DGroupingNode):
    def __init__(self, **kwargs):
        super(HAnimSegment, self).__init__(**kwargs)
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        centerOfMass  = kwargs.pop("centerOfMass", [0, 0, 0])
        self.__centerOfMass = centerOfMass
        children  = kwargs.pop("children", None)
        self.__children = children
        coord  = kwargs.pop("coord", None)
        self.__coord = coord
        description  = kwargs.pop("description", None)
        self.__description = description
        displacers  = kwargs.pop("displacers", None)
        self.__displacers = displacers
        mass  = kwargs.pop("mass", 0)
        if mass == None or mass  <  0:
            return None
        self.__mass = mass
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        momentsOfInertia  = kwargs.pop("momentsOfInertia", [0, 0, 0, 0, 0, 0, 0, 0, 0])
        if momentsOfInertia == None or len(momentsOfInertia) <= 0 or min(momentsOfInertia)  <  0:
            return None
        self.__momentsOfInertia = momentsOfInertia
        name  = kwargs.pop("name", None)
        self.__name = name
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    def addChildren(self, Children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [Children]
        return self
    @property
    def centerOfMass(self):
        return self.__centerOfMass
    @centerOfMass.setter
    def centerOfMass(self, value = [0, 0, 0]):
        self.__centerOfMass = [value]
    def setCenterOfMass(self, centerOfMass = [0, 0, 0]):
        self.__centerOfMass = [centerOfMass]
        return self
    def addCenterOfMass(self, centerOfMass = [0, 0, 0]):
        if self.__centerOfMass == None:            self.__centerOfMass =  []
        self.__centerOfMass +=  [centerOfMass]
        return self
    def removeCenterOfMass(self, centerOfMass):
        self.__centerOfMass = [x for x in self.__centerOfMass if x not in centerOfMass]
        return self.__centerOfMass
    def getCenterOfMass(self, centerOfMass = [0, 0, 0]):
        return self.__centerOfMass
    def centerOfMass_changed(self, centerOfMass = [0, 0, 0]):
        return self.__centerOfMass
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    @property
    def coord(self):
        return self.__coord
    @coord.setter
    def coord(self, value = None):
        self.__coord = [value]
    def setCoord(self, coord = None):
        self.__coord = [coord]
        return self
    def addCoord(self, coord = None):
        if self.__coord == None:            self.__coord =  []
        self.__coord +=  [coord]
        return self
    def removeCoord(self, coord):
        self.__coord = [x for x in self.__coord if x not in coord]
        return self.__coord
    def getCoord(self, coord = None):
        return self.__coord
    def coord_changed(self, coord = None):
        return self.__coord
    @property
    def description(self):
        return self.__description
    @description.setter
    def description(self, value = None):
        self.__description = [value]
    def setDescription(self, description = None):
        self.__description = [description]
        return self
    def addDescription(self, description = None):
        if self.__description == None:            self.__description =  []
        self.__description +=  [description]
        return self
    def removeDescription(self, description):
        self.__description = [x for x in self.__description if x not in description]
        return self.__description
    def getDescription(self, description = None):
        return self.__description
    def description_changed(self, description = None):
        return self.__description
    @property
    def displacers(self):
        return self.__displacers
    @displacers.setter
    def displacers(self, value = None):
        self.__displacers = [value]
    def setDisplacers(self, displacers = None):
        self.__displacers = [displacers]
        return self
    def addDisplacers(self, displacers = None):
        if self.__displacers == None:            self.__displacers =  []
        self.__displacers +=  [displacers]
        return self
    def removeDisplacers(self, displacers):
        self.__displacers = [x for x in self.__displacers if x not in displacers]
        return self.__displacers
    def getDisplacers(self, displacers = None):
        return self.__displacers
    def displacers_changed(self, displacers = None):
        return self.__displacers
    @property
    def mass(self):
        return self.__mass
    @mass.setter
    def mass(self, value = 0):
        if value == None or value  <  0:
            return None
        self.__mass = [value]
    def setMass(self, mass = 0):
        if mass == None or mass  <  0:
            return None
        self.__mass = [mass]
        return self
    def addMass(self, mass = 0):
        if mass == None or mass  <  0:
            return None
        if self.__mass == None:            self.__mass =  []
        self.__mass +=  [mass]
        return self
    def removeMass(self, mass):
        self.__mass = [x for x in self.__mass if x not in mass]
        return self.__mass
    def getMass(self, mass = 0):
        return self.__mass
    def mass_changed(self, mass = 0):
        return self.__mass
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def momentsOfInertia(self):
        return self.__momentsOfInertia
    @momentsOfInertia.setter
    def momentsOfInertia(self, value = [0, 0, 0, 0, 0, 0, 0, 0, 0]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        self.__momentsOfInertia = [value]
    def setMomentsOfInertia(self, momentsOfInertia = [0, 0, 0, 0, 0, 0, 0, 0, 0]):
        if momentsOfInertia == None or len(momentsOfInertia) <= 0 or min(momentsOfInertia)  <  0:
            return None
        self.__momentsOfInertia = [momentsOfInertia]
        return self
    def addMomentsOfInertia(self, momentsOfInertia = [0, 0, 0, 0, 0, 0, 0, 0, 0]):
        if momentsOfInertia == None or len(momentsOfInertia) <= 0 or min(momentsOfInertia)  <  0:
            return None
        if self.__momentsOfInertia == None:            self.__momentsOfInertia =  []
        self.__momentsOfInertia +=  [momentsOfInertia]
        return self
    def removeMomentsOfInertia(self, momentsOfInertia):
        self.__momentsOfInertia = [x for x in self.__momentsOfInertia if x not in momentsOfInertia]
        return self.__momentsOfInertia
    def getMomentsOfInertia(self, momentsOfInertia = [0, 0, 0, 0, 0, 0, 0, 0, 0]):
        return self.__momentsOfInertia
    def momentsOfInertia_changed(self, momentsOfInertia = [0, 0, 0, 0, 0, 0, 0, 0, 0]):
        return self.__momentsOfInertia
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        self.__name = [value]
    def setName(self, name = None):
        self.__name = [name]
        return self
    def addName(self, name = None):
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<HAnimSegment'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__centerOfMass is not None:
            if isinstance(self.__centerOfMass, six.string_types):
                str += ' centerOfMass="'+self.__centerOfMass+'"'
            else:
                str += ' centerOfMass="'+self.__centerOfMass[0]+'"'
        if self.__description is not None:
            if isinstance(self.__description, six.string_types):
                str += ' description="'+self.__description+'"'
            else:
                str += ' description="'+self.__description[0]+'"'
        if self.__mass is not None:
            if isinstance(self.__mass, six.string_types):
                str += ' mass="'+self.__mass+'"'
            else:
                str += ' mass="'+self.__mass[0]+'"'
        if self.__momentsOfInertia is not None:
            if isinstance(self.__momentsOfInertia, six.string_types):
                str += ' momentsOfInertia="'+self.__momentsOfInertia+'"'
            else:
                str += ' momentsOfInertia="'+self.__momentsOfInertia[0]+'"'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '<coord'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</coord>'
        str += '<displacers'
        if self.__displacers is not None:
           for s in self.__displacers:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__displacers is not None:
           for s in self.__displacers:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</displacers>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '</HAnimSegment>'
        return str


class HAnimSite(X3DGroupingNode):
    def __init__(self, **kwargs):
        super(HAnimSite, self).__init__(**kwargs)
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        center  = kwargs.pop("center", [0, 0, 0])
        self.__center = center
        children  = kwargs.pop("children", None)
        self.__children = children
        description  = kwargs.pop("description", None)
        self.__description = description
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        name  = kwargs.pop("name", None)
        self.__name = name
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        rotation  = kwargs.pop("rotation", [0, 0, 1, 0])
        self.__rotation = rotation
        scale  = kwargs.pop("scale", [1, 1, 1])
        if scale == None or len(scale) <= 0 or min(scale)  <=  0:
            return None
        self.__scale = scale
        scaleOrientation  = kwargs.pop("scaleOrientation", [0, 0, 1, 0])
        self.__scaleOrientation = scaleOrientation
        translation  = kwargs.pop("translation", [0, 0, 0])
        self.__translation = translation
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    def addChildren(self, Children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [Children]
        return self
    @property
    def center(self):
        return self.__center
    @center.setter
    def center(self, value = [0, 0, 0]):
        self.__center = [value]
    def setCenter(self, center = [0, 0, 0]):
        self.__center = [center]
        return self
    def addCenter(self, center = [0, 0, 0]):
        if self.__center == None:            self.__center =  []
        self.__center +=  [center]
        return self
    def removeCenter(self, center):
        self.__center = [x for x in self.__center if x not in center]
        return self.__center
    def getCenter(self, center = [0, 0, 0]):
        return self.__center
    def center_changed(self, center = [0, 0, 0]):
        return self.__center
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    @property
    def description(self):
        return self.__description
    @description.setter
    def description(self, value = None):
        self.__description = [value]
    def setDescription(self, description = None):
        self.__description = [description]
        return self
    def addDescription(self, description = None):
        if self.__description == None:            self.__description =  []
        self.__description +=  [description]
        return self
    def removeDescription(self, description):
        self.__description = [x for x in self.__description if x not in description]
        return self.__description
    def getDescription(self, description = None):
        return self.__description
    def description_changed(self, description = None):
        return self.__description
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        self.__name = [value]
    def setName(self, name = None):
        self.__name = [name]
        return self
    def addName(self, name = None):
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    @property
    def rotation(self):
        return self.__rotation
    @rotation.setter
    def rotation(self, value = [0, 0, 1, 0]):
        self.__rotation = [value]
    def setRotation(self, rotation = [0, 0, 1, 0]):
        self.__rotation = [rotation]
        return self
    def addRotation(self, rotation = [0, 0, 1, 0]):
        if self.__rotation == None:            self.__rotation =  []
        self.__rotation +=  [rotation]
        return self
    def removeRotation(self, rotation):
        self.__rotation = [x for x in self.__rotation if x not in rotation]
        return self.__rotation
    def getRotation(self, rotation = [0, 0, 1, 0]):
        return self.__rotation
    def rotation_changed(self, rotation = [0, 0, 1, 0]):
        return self.__rotation
    @property
    def scale(self):
        return self.__scale
    @scale.setter
    def scale(self, value = [1, 1, 1]):
        if value == None or len(value) <= 0 or min(value)  <=  0:
            return None
        self.__scale = [value]
    def setScale(self, scale = [1, 1, 1]):
        if scale == None or len(scale) <= 0 or min(scale)  <=  0:
            return None
        self.__scale = [scale]
        return self
    def addScale(self, scale = [1, 1, 1]):
        if scale == None or len(scale) <= 0 or min(scale)  <=  0:
            return None
        if self.__scale == None:            self.__scale =  []
        self.__scale +=  [scale]
        return self
    def removeScale(self, scale):
        self.__scale = [x for x in self.__scale if x not in scale]
        return self.__scale
    def getScale(self, scale = [1, 1, 1]):
        return self.__scale
    def scale_changed(self, scale = [1, 1, 1]):
        return self.__scale
    @property
    def scaleOrientation(self):
        return self.__scaleOrientation
    @scaleOrientation.setter
    def scaleOrientation(self, value = [0, 0, 1, 0]):
        self.__scaleOrientation = [value]
    def setScaleOrientation(self, scaleOrientation = [0, 0, 1, 0]):
        self.__scaleOrientation = [scaleOrientation]
        return self
    def addScaleOrientation(self, scaleOrientation = [0, 0, 1, 0]):
        if self.__scaleOrientation == None:            self.__scaleOrientation =  []
        self.__scaleOrientation +=  [scaleOrientation]
        return self
    def removeScaleOrientation(self, scaleOrientation):
        self.__scaleOrientation = [x for x in self.__scaleOrientation if x not in scaleOrientation]
        return self.__scaleOrientation
    def getScaleOrientation(self, scaleOrientation = [0, 0, 1, 0]):
        return self.__scaleOrientation
    def scaleOrientation_changed(self, scaleOrientation = [0, 0, 1, 0]):
        return self.__scaleOrientation
    @property
    def translation(self):
        return self.__translation
    @translation.setter
    def translation(self, value = [0, 0, 0]):
        self.__translation = [value]
    def setTranslation(self, translation = [0, 0, 0]):
        self.__translation = [translation]
        return self
    def addTranslation(self, translation = [0, 0, 0]):
        if self.__translation == None:            self.__translation =  []
        self.__translation +=  [translation]
        return self
    def removeTranslation(self, translation):
        self.__translation = [x for x in self.__translation if x not in translation]
        return self.__translation
    def getTranslation(self, translation = [0, 0, 0]):
        return self.__translation
    def translation_changed(self, translation = [0, 0, 0]):
        return self.__translation
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<HAnimSite'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__center is not None:
            if isinstance(self.__center, six.string_types):
                str += ' center="'+self.__center+'"'
            else:
                str += ' center="'+self.__center[0]+'"'
        if self.__description is not None:
            if isinstance(self.__description, six.string_types):
                str += ' description="'+self.__description+'"'
            else:
                str += ' description="'+self.__description[0]+'"'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        if self.__rotation is not None:
            if isinstance(self.__rotation, six.string_types):
                str += ' rotation="'+self.__rotation+'"'
            else:
                str += ' rotation="'+self.__rotation[0]+'"'
        if self.__scale is not None:
            if isinstance(self.__scale, six.string_types):
                str += ' scale="'+self.__scale+'"'
            else:
                str += ' scale="'+self.__scale[0]+'"'
        if self.__scaleOrientation is not None:
            if isinstance(self.__scaleOrientation, six.string_types):
                str += ' scaleOrientation="'+self.__scaleOrientation+'"'
            else:
                str += ' scaleOrientation="'+self.__scaleOrientation[0]+'"'
        if self.__translation is not None:
            if isinstance(self.__translation, six.string_types):
                str += ' translation="'+self.__translation+'"'
            else:
                str += ' translation="'+self.__translation[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '</HAnimSite>'
        return str


class ImageCubeMapTexture(X3DUrlObject, X3DEnvironmentTextureNode):
    def __init__(self, **kwargs):
        super(ImageCubeMapTexture, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        textureProperties  = kwargs.pop("textureProperties", None)
        self.__textureProperties = textureProperties
        url  = kwargs.pop("url", None)
        self.__url = url
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def url(self):
        return self.__url
    @url.setter
    def url(self, value = None):
        self.__url = [value]
    def setUrl(self, url = None):
        self.__url = [url]
        return self
    def addUrl(self, url = None):
        if self.__url == None:            self.__url =  []
        self.__url +=  [url]
        return self
    def removeUrl(self, url):
        self.__url = [x for x in self.__url if x not in url]
        return self.__url
    def getUrl(self, url = None):
        return self.__url
    def url_changed(self, url = None):
        return self.__url
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ImageCubeMapTexture'
        if self.__url is not None:
            if isinstance(self.__url, six.string_types):
                str += ' url="'+self.__url+'"'
            else:
                str += ' url="'+self.__url[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<textureProperties'
        if self.__textureProperties is not None:
           for s in self.__textureProperties:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__textureProperties is not None:
           for s in self.__textureProperties:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</textureProperties>'
        str += '</ImageCubeMapTexture>'
        return str


class ImageTexture(X3DUrlObject, X3DTexture2DNode):
    def __init__(self, **kwargs):
        super(ImageTexture, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        repeatS  = kwargs.pop("repeatS", True)
        self.__repeatS = repeatS
        repeatT  = kwargs.pop("repeatT", True)
        self.__repeatT = repeatT
        textureProperties  = kwargs.pop("textureProperties", None)
        self.__textureProperties = textureProperties
        url  = kwargs.pop("url", None)
        self.__url = url
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def url(self):
        return self.__url
    @url.setter
    def url(self, value = None):
        self.__url = [value]
    def setUrl(self, url = None):
        self.__url = [url]
        return self
    def addUrl(self, url = None):
        if self.__url == None:            self.__url =  []
        self.__url +=  [url]
        return self
    def removeUrl(self, url):
        self.__url = [x for x in self.__url if x not in url]
        return self.__url
    def getUrl(self, url = None):
        return self.__url
    def url_changed(self, url = None):
        return self.__url
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ImageTexture'
        if self.__repeatS is not None:
            if isinstance(self.__repeatS, six.string_types):
                str += ' repeatS="'+self.__repeatS+'"'
            else:
                str += ' repeatS="'+self.__repeatS[0]+'"'
        if self.__repeatT is not None:
            if isinstance(self.__repeatT, six.string_types):
                str += ' repeatT="'+self.__repeatT+'"'
            else:
                str += ' repeatT="'+self.__repeatT[0]+'"'
        if self.__url is not None:
            if isinstance(self.__url, six.string_types):
                str += ' url="'+self.__url+'"'
            else:
                str += ' url="'+self.__url[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<textureProperties'
        if self.__textureProperties is not None:
           for s in self.__textureProperties:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__textureProperties is not None:
           for s in self.__textureProperties:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</textureProperties>'
        str += '</ImageTexture>'
        return str


class ImageTexture3D(X3DUrlObject, X3DTexture3DNode):
    def __init__(self, **kwargs):
        super(ImageTexture3D, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        repeatR  = kwargs.pop("repeatR", False)
        self.__repeatR = repeatR
        repeatS  = kwargs.pop("repeatS", False)
        self.__repeatS = repeatS
        repeatT  = kwargs.pop("repeatT", False)
        self.__repeatT = repeatT
        textureProperties  = kwargs.pop("textureProperties", None)
        self.__textureProperties = textureProperties
        url  = kwargs.pop("url", None)
        self.__url = url
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def url(self):
        return self.__url
    @url.setter
    def url(self, value = None):
        self.__url = [value]
    def setUrl(self, url = None):
        self.__url = [url]
        return self
    def addUrl(self, url = None):
        if self.__url == None:            self.__url =  []
        self.__url +=  [url]
        return self
    def removeUrl(self, url):
        self.__url = [x for x in self.__url if x not in url]
        return self.__url
    def getUrl(self, url = None):
        return self.__url
    def url_changed(self, url = None):
        return self.__url
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ImageTexture3D'
        if self.__repeatR is not None:
            if isinstance(self.__repeatR, six.string_types):
                str += ' repeatR="'+self.__repeatR+'"'
            else:
                str += ' repeatR="'+self.__repeatR[0]+'"'
        if self.__repeatS is not None:
            if isinstance(self.__repeatS, six.string_types):
                str += ' repeatS="'+self.__repeatS+'"'
            else:
                str += ' repeatS="'+self.__repeatS[0]+'"'
        if self.__repeatT is not None:
            if isinstance(self.__repeatT, six.string_types):
                str += ' repeatT="'+self.__repeatT+'"'
            else:
                str += ' repeatT="'+self.__repeatT[0]+'"'
        if self.__url is not None:
            if isinstance(self.__url, six.string_types):
                str += ' url="'+self.__url+'"'
            else:
                str += ' url="'+self.__url[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<textureProperties'
        if self.__textureProperties is not None:
           for s in self.__textureProperties:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__textureProperties is not None:
           for s in self.__textureProperties:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</textureProperties>'
        str += '</ImageTexture3D>'
        return str


class IndexedFaceSet(X3DComposedGeometryNode):
    def __init__(self, **kwargs):
        super(IndexedFaceSet, self).__init__(**kwargs)
        attrib  = kwargs.pop("attrib", None)
        self.__attrib = attrib
        ccw  = kwargs.pop("ccw", True)
        self.__ccw = ccw
        color  = kwargs.pop("color", None)
        self.__color = color
        colorIndex  = kwargs.pop("colorIndex", None)
        if colorIndex == None or len(colorIndex) <= 0 or min(colorIndex)  <  -1:
            return None
        self.__colorIndex = colorIndex
        colorPerVertex  = kwargs.pop("colorPerVertex", True)
        self.__colorPerVertex = colorPerVertex
        convex  = kwargs.pop("convex", True)
        self.__convex = convex
        coord  = kwargs.pop("coord", None)
        self.__coord = coord
        coordIndex  = kwargs.pop("coordIndex", None)
        if coordIndex == None or len(coordIndex) <= 0 or min(coordIndex)  <  -1:
            return None
        self.__coordIndex = coordIndex
        creaseAngle  = kwargs.pop("creaseAngle", 0)
        if creaseAngle == None or creaseAngle  <  0:
            return None
        self.__creaseAngle = creaseAngle
        fogCoord  = kwargs.pop("fogCoord", None)
        self.__fogCoord = fogCoord
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        normal  = kwargs.pop("normal", None)
        self.__normal = normal
        normalIndex  = kwargs.pop("normalIndex", None)
        if normalIndex == None or len(normalIndex) <= 0 or min(normalIndex)  <  -1:
            return None
        self.__normalIndex = normalIndex
        normalPerVertex  = kwargs.pop("normalPerVertex", True)
        self.__normalPerVertex = normalPerVertex
        colorIndex  = kwargs.pop("colorIndex", None)
        if colorIndex == None or len(colorIndex) <= 0 or min(colorIndex)  <  -1:
            return None
        self.__colorIndex = colorIndex
        coordIndex  = kwargs.pop("coordIndex", None)
        if coordIndex == None or len(coordIndex) <= 0 or min(coordIndex)  <  -1:
            return None
        self.__coordIndex = coordIndex
        normalIndex  = kwargs.pop("normalIndex", None)
        if normalIndex == None or len(normalIndex) <= 0 or min(normalIndex)  <  -1:
            return None
        self.__normalIndex = normalIndex
        texCoordIndex  = kwargs.pop("texCoordIndex", None)
        if texCoordIndex == None or len(texCoordIndex) <= 0 or min(texCoordIndex)  <  -1:
            return None
        self.__texCoordIndex = texCoordIndex
        solid  = kwargs.pop("solid", True)
        self.__solid = solid
        texCoord  = kwargs.pop("texCoord", None)
        self.__texCoord = texCoord
        texCoordIndex  = kwargs.pop("texCoordIndex", None)
        if texCoordIndex == None or len(texCoordIndex) <= 0 or min(texCoordIndex)  <  -1:
            return None
        self.__texCoordIndex = texCoordIndex
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def attrib(self):
        return self.__attrib
    @attrib.setter
    def attrib(self, value = None):
        self.__attrib = [value]
    def setAttrib(self, attrib = None):
        self.__attrib = [attrib]
        return self
    def addAttrib(self, attrib = None):
        if self.__attrib == None:            self.__attrib =  []
        self.__attrib +=  [attrib]
        return self
    def removeAttrib(self, attrib):
        self.__attrib = [x for x in self.__attrib if x not in attrib]
        return self.__attrib
    def getAttrib(self, attrib = None):
        return self.__attrib
    def attrib_changed(self, attrib = None):
        return self.__attrib
    @property
    def color(self):
        return self.__color
    @color.setter
    def color(self, value = None):
        self.__color = [value]
    def setColor(self, color = None):
        self.__color = [color]
        return self
    def addColor(self, color = None):
        if self.__color == None:            self.__color =  []
        self.__color +=  [color]
        return self
    def removeColor(self, color):
        self.__color = [x for x in self.__color if x not in color]
        return self.__color
    def getColor(self, color = None):
        return self.__color
    def color_changed(self, color = None):
        return self.__color
    @property
    def coord(self):
        return self.__coord
    @coord.setter
    def coord(self, value = None):
        self.__coord = [value]
    def setCoord(self, coord = None):
        self.__coord = [coord]
        return self
    def addCoord(self, coord = None):
        if self.__coord == None:            self.__coord =  []
        self.__coord +=  [coord]
        return self
    def removeCoord(self, coord):
        self.__coord = [x for x in self.__coord if x not in coord]
        return self.__coord
    def getCoord(self, coord = None):
        return self.__coord
    def coord_changed(self, coord = None):
        return self.__coord
    @property
    def fogCoord(self):
        return self.__fogCoord
    @fogCoord.setter
    def fogCoord(self, value = None):
        self.__fogCoord = [value]
    def setFogCoord(self, fogCoord = None):
        self.__fogCoord = [fogCoord]
        return self
    def addFogCoord(self, fogCoord = None):
        if self.__fogCoord == None:            self.__fogCoord =  []
        self.__fogCoord +=  [fogCoord]
        return self
    def removeFogCoord(self, fogCoord):
        self.__fogCoord = [x for x in self.__fogCoord if x not in fogCoord]
        return self.__fogCoord
    def getFogCoord(self, fogCoord = None):
        return self.__fogCoord
    def fogCoord_changed(self, fogCoord = None):
        return self.__fogCoord
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def normal(self):
        return self.__normal
    @normal.setter
    def normal(self, value = None):
        self.__normal = [value]
    def setNormal(self, normal = None):
        self.__normal = [normal]
        return self
    def addNormal(self, normal = None):
        if self.__normal == None:            self.__normal =  []
        self.__normal +=  [normal]
        return self
    def removeNormal(self, normal):
        self.__normal = [x for x in self.__normal if x not in normal]
        return self.__normal
    def getNormal(self, normal = None):
        return self.__normal
    def normal_changed(self, normal = None):
        return self.__normal
    @property
    def colorIndex(self):
        return self.__colorIndex
    @colorIndex.setter
    def colorIndex(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  -1:
            return None
        self.__colorIndex = [value]
    def set_colorIndex(self, colorIndex = None):
        if colorIndex == None or len(colorIndex) <= 0 or min(colorIndex)  <  -1:
            return None
        self.__colorIndex = [colorIndex]
        return self
    @property
    def coordIndex(self):
        return self.__coordIndex
    @coordIndex.setter
    def coordIndex(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  -1:
            return None
        self.__coordIndex = [value]
    def set_coordIndex(self, coordIndex = None):
        if coordIndex == None or len(coordIndex) <= 0 or min(coordIndex)  <  -1:
            return None
        self.__coordIndex = [coordIndex]
        return self
    @property
    def normalIndex(self):
        return self.__normalIndex
    @normalIndex.setter
    def normalIndex(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  -1:
            return None
        self.__normalIndex = [value]
    def set_normalIndex(self, normalIndex = None):
        if normalIndex == None or len(normalIndex) <= 0 or min(normalIndex)  <  -1:
            return None
        self.__normalIndex = [normalIndex]
        return self
    @property
    def texCoordIndex(self):
        return self.__texCoordIndex
    @texCoordIndex.setter
    def texCoordIndex(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  -1:
            return None
        self.__texCoordIndex = [value]
    def set_texCoordIndex(self, texCoordIndex = None):
        if texCoordIndex == None or len(texCoordIndex) <= 0 or min(texCoordIndex)  <  -1:
            return None
        self.__texCoordIndex = [texCoordIndex]
        return self
    @property
    def texCoord(self):
        return self.__texCoord
    @texCoord.setter
    def texCoord(self, value = None):
        self.__texCoord = [value]
    def setTexCoord(self, texCoord = None):
        self.__texCoord = [texCoord]
        return self
    def addTexCoord(self, texCoord = None):
        if self.__texCoord == None:            self.__texCoord =  []
        self.__texCoord +=  [texCoord]
        return self
    def removeTexCoord(self, texCoord):
        self.__texCoord = [x for x in self.__texCoord if x not in texCoord]
        return self.__texCoord
    def getTexCoord(self, texCoord = None):
        return self.__texCoord
    def texCoord_changed(self, texCoord = None):
        return self.__texCoord
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<IndexedFaceSet'
        if self.__ccw is not None:
            if isinstance(self.__ccw, six.string_types):
                str += ' ccw="'+self.__ccw+'"'
            else:
                str += ' ccw="'+self.__ccw[0]+'"'
        if self.__colorIndex is not None:
            if isinstance(self.__colorIndex, six.string_types):
                str += ' colorIndex="'+self.__colorIndex+'"'
            else:
                str += ' colorIndex="'+self.__colorIndex[0]+'"'
        if self.__colorPerVertex is not None:
            if isinstance(self.__colorPerVertex, six.string_types):
                str += ' colorPerVertex="'+self.__colorPerVertex+'"'
            else:
                str += ' colorPerVertex="'+self.__colorPerVertex[0]+'"'
        if self.__convex is not None:
            if isinstance(self.__convex, six.string_types):
                str += ' convex="'+self.__convex+'"'
            else:
                str += ' convex="'+self.__convex[0]+'"'
        if self.__coordIndex is not None:
            if isinstance(self.__coordIndex, six.string_types):
                str += ' coordIndex="'+self.__coordIndex+'"'
            else:
                str += ' coordIndex="'+self.__coordIndex[0]+'"'
        if self.__creaseAngle is not None:
            if isinstance(self.__creaseAngle, six.string_types):
                str += ' creaseAngle="'+self.__creaseAngle+'"'
            else:
                str += ' creaseAngle="'+self.__creaseAngle[0]+'"'
        if self.__normalIndex is not None:
            if isinstance(self.__normalIndex, six.string_types):
                str += ' normalIndex="'+self.__normalIndex+'"'
            else:
                str += ' normalIndex="'+self.__normalIndex[0]+'"'
        if self.__normalPerVertex is not None:
            if isinstance(self.__normalPerVertex, six.string_types):
                str += ' normalPerVertex="'+self.__normalPerVertex+'"'
            else:
                str += ' normalPerVertex="'+self.__normalPerVertex[0]+'"'
        if self.__colorIndex is not None:
            if isinstance(self.__colorIndex, six.string_types):
                str += ' colorIndex="'+self.__colorIndex+'"'
            else:
                str += ' colorIndex="'+self.__colorIndex[0]+'"'
        if self.__coordIndex is not None:
            if isinstance(self.__coordIndex, six.string_types):
                str += ' coordIndex="'+self.__coordIndex+'"'
            else:
                str += ' coordIndex="'+self.__coordIndex[0]+'"'
        if self.__normalIndex is not None:
            if isinstance(self.__normalIndex, six.string_types):
                str += ' normalIndex="'+self.__normalIndex+'"'
            else:
                str += ' normalIndex="'+self.__normalIndex[0]+'"'
        if self.__texCoordIndex is not None:
            if isinstance(self.__texCoordIndex, six.string_types):
                str += ' texCoordIndex="'+self.__texCoordIndex+'"'
            else:
                str += ' texCoordIndex="'+self.__texCoordIndex[0]+'"'
        if self.__solid is not None:
            if isinstance(self.__solid, six.string_types):
                str += ' solid="'+self.__solid+'"'
            else:
                str += ' solid="'+self.__solid[0]+'"'
        if self.__texCoordIndex is not None:
            if isinstance(self.__texCoordIndex, six.string_types):
                str += ' texCoordIndex="'+self.__texCoordIndex+'"'
            else:
                str += ' texCoordIndex="'+self.__texCoordIndex[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<attrib'
        if self.__attrib is not None:
           for s in self.__attrib:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__attrib is not None:
           for s in self.__attrib:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</attrib>'
        str += '<color'
        if self.__color is not None:
           for s in self.__color:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__color is not None:
           for s in self.__color:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</color>'
        str += '<coord'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</coord>'
        str += '<fogCoord'
        if self.__fogCoord is not None:
           for s in self.__fogCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__fogCoord is not None:
           for s in self.__fogCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</fogCoord>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<normal'
        if self.__normal is not None:
           for s in self.__normal:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__normal is not None:
           for s in self.__normal:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</normal>'
        str += '<texCoord'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</texCoord>'
        str += '</IndexedFaceSet>'
        return str


class IndexedLineSet(X3DGeometryNode):
    def __init__(self, **kwargs):
        super(IndexedLineSet, self).__init__(**kwargs)
        attrib  = kwargs.pop("attrib", None)
        self.__attrib = attrib
        color  = kwargs.pop("color", None)
        self.__color = color
        colorIndex  = kwargs.pop("colorIndex", None)
        if colorIndex == None or len(colorIndex) <= 0 or min(colorIndex)  <  -1:
            return None
        self.__colorIndex = colorIndex
        colorPerVertex  = kwargs.pop("colorPerVertex", True)
        self.__colorPerVertex = colorPerVertex
        coord  = kwargs.pop("coord", None)
        self.__coord = coord
        coordIndex  = kwargs.pop("coordIndex", None)
        if coordIndex == None or len(coordIndex) <= 0 or min(coordIndex)  <  -1:
            return None
        self.__coordIndex = coordIndex
        fogCoord  = kwargs.pop("fogCoord", None)
        self.__fogCoord = fogCoord
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        colorIndex  = kwargs.pop("colorIndex", None)
        if colorIndex == None or len(colorIndex) <= 0 or min(colorIndex)  <  -1:
            return None
        self.__colorIndex = colorIndex
        coordIndex  = kwargs.pop("coordIndex", None)
        if coordIndex == None or len(coordIndex) <= 0 or min(coordIndex)  <  -1:
            return None
        self.__coordIndex = coordIndex
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def attrib(self):
        return self.__attrib
    @attrib.setter
    def attrib(self, value = None):
        self.__attrib = [value]
    def setAttrib(self, attrib = None):
        self.__attrib = [attrib]
        return self
    def addAttrib(self, attrib = None):
        if self.__attrib == None:            self.__attrib =  []
        self.__attrib +=  [attrib]
        return self
    def removeAttrib(self, attrib):
        self.__attrib = [x for x in self.__attrib if x not in attrib]
        return self.__attrib
    def getAttrib(self, attrib = None):
        return self.__attrib
    def attrib_changed(self, attrib = None):
        return self.__attrib
    @property
    def color(self):
        return self.__color
    @color.setter
    def color(self, value = None):
        self.__color = [value]
    def setColor(self, color = None):
        self.__color = [color]
        return self
    def addColor(self, color = None):
        if self.__color == None:            self.__color =  []
        self.__color +=  [color]
        return self
    def removeColor(self, color):
        self.__color = [x for x in self.__color if x not in color]
        return self.__color
    def getColor(self, color = None):
        return self.__color
    def color_changed(self, color = None):
        return self.__color
    @property
    def coord(self):
        return self.__coord
    @coord.setter
    def coord(self, value = None):
        self.__coord = [value]
    def setCoord(self, coord = None):
        self.__coord = [coord]
        return self
    def addCoord(self, coord = None):
        if self.__coord == None:            self.__coord =  []
        self.__coord +=  [coord]
        return self
    def removeCoord(self, coord):
        self.__coord = [x for x in self.__coord if x not in coord]
        return self.__coord
    def getCoord(self, coord = None):
        return self.__coord
    def coord_changed(self, coord = None):
        return self.__coord
    @property
    def fogCoord(self):
        return self.__fogCoord
    @fogCoord.setter
    def fogCoord(self, value = None):
        self.__fogCoord = [value]
    def setFogCoord(self, fogCoord = None):
        self.__fogCoord = [fogCoord]
        return self
    def addFogCoord(self, fogCoord = None):
        if self.__fogCoord == None:            self.__fogCoord =  []
        self.__fogCoord +=  [fogCoord]
        return self
    def removeFogCoord(self, fogCoord):
        self.__fogCoord = [x for x in self.__fogCoord if x not in fogCoord]
        return self.__fogCoord
    def getFogCoord(self, fogCoord = None):
        return self.__fogCoord
    def fogCoord_changed(self, fogCoord = None):
        return self.__fogCoord
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def colorIndex(self):
        return self.__colorIndex
    @colorIndex.setter
    def colorIndex(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  -1:
            return None
        self.__colorIndex = [value]
    def set_colorIndex(self, colorIndex = None):
        if colorIndex == None or len(colorIndex) <= 0 or min(colorIndex)  <  -1:
            return None
        self.__colorIndex = [colorIndex]
        return self
    @property
    def coordIndex(self):
        return self.__coordIndex
    @coordIndex.setter
    def coordIndex(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  -1:
            return None
        self.__coordIndex = [value]
    def set_coordIndex(self, coordIndex = None):
        if coordIndex == None or len(coordIndex) <= 0 or min(coordIndex)  <  -1:
            return None
        self.__coordIndex = [coordIndex]
        return self
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<IndexedLineSet'
        if self.__colorIndex is not None:
            if isinstance(self.__colorIndex, six.string_types):
                str += ' colorIndex="'+self.__colorIndex+'"'
            else:
                str += ' colorIndex="'+self.__colorIndex[0]+'"'
        if self.__colorPerVertex is not None:
            if isinstance(self.__colorPerVertex, six.string_types):
                str += ' colorPerVertex="'+self.__colorPerVertex+'"'
            else:
                str += ' colorPerVertex="'+self.__colorPerVertex[0]+'"'
        if self.__coordIndex is not None:
            if isinstance(self.__coordIndex, six.string_types):
                str += ' coordIndex="'+self.__coordIndex+'"'
            else:
                str += ' coordIndex="'+self.__coordIndex[0]+'"'
        if self.__colorIndex is not None:
            if isinstance(self.__colorIndex, six.string_types):
                str += ' colorIndex="'+self.__colorIndex+'"'
            else:
                str += ' colorIndex="'+self.__colorIndex[0]+'"'
        if self.__coordIndex is not None:
            if isinstance(self.__coordIndex, six.string_types):
                str += ' coordIndex="'+self.__coordIndex+'"'
            else:
                str += ' coordIndex="'+self.__coordIndex[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<attrib'
        if self.__attrib is not None:
           for s in self.__attrib:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__attrib is not None:
           for s in self.__attrib:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</attrib>'
        str += '<color'
        if self.__color is not None:
           for s in self.__color:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__color is not None:
           for s in self.__color:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</color>'
        str += '<coord'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</coord>'
        str += '<fogCoord'
        if self.__fogCoord is not None:
           for s in self.__fogCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__fogCoord is not None:
           for s in self.__fogCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</fogCoord>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</IndexedLineSet>'
        return str


class IndexedQuadSet(X3DComposedGeometryNode):
    def __init__(self, **kwargs):
        super(IndexedQuadSet, self).__init__(**kwargs)
        attrib  = kwargs.pop("attrib", None)
        self.__attrib = attrib
        ccw  = kwargs.pop("ccw", True)
        self.__ccw = ccw
        color  = kwargs.pop("color", None)
        self.__color = color
        colorPerVertex  = kwargs.pop("colorPerVertex", True)
        self.__colorPerVertex = colorPerVertex
        coord  = kwargs.pop("coord", None)
        self.__coord = coord
        fogCoord  = kwargs.pop("fogCoord", None)
        self.__fogCoord = fogCoord
        index  = kwargs.pop("index", None)
        if index == None or len(index) <= 0 or min(index)  <  0:
            return None
        self.__index = index
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        normal  = kwargs.pop("normal", None)
        self.__normal = normal
        normalPerVertex  = kwargs.pop("normalPerVertex", True)
        self.__normalPerVertex = normalPerVertex
        index  = kwargs.pop("index", None)
        if index == None or len(index) <= 0 or min(index)  <  0:
            return None
        self.__index = index
        solid  = kwargs.pop("solid", True)
        self.__solid = solid
        texCoord  = kwargs.pop("texCoord", None)
        self.__texCoord = texCoord
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def attrib(self):
        return self.__attrib
    @attrib.setter
    def attrib(self, value = None):
        self.__attrib = [value]
    def setAttrib(self, attrib = None):
        self.__attrib = [attrib]
        return self
    def addAttrib(self, attrib = None):
        if self.__attrib == None:            self.__attrib =  []
        self.__attrib +=  [attrib]
        return self
    def removeAttrib(self, attrib):
        self.__attrib = [x for x in self.__attrib if x not in attrib]
        return self.__attrib
    def getAttrib(self, attrib = None):
        return self.__attrib
    def attrib_changed(self, attrib = None):
        return self.__attrib
    @property
    def color(self):
        return self.__color
    @color.setter
    def color(self, value = None):
        self.__color = [value]
    def setColor(self, color = None):
        self.__color = [color]
        return self
    def addColor(self, color = None):
        if self.__color == None:            self.__color =  []
        self.__color +=  [color]
        return self
    def removeColor(self, color):
        self.__color = [x for x in self.__color if x not in color]
        return self.__color
    def getColor(self, color = None):
        return self.__color
    def color_changed(self, color = None):
        return self.__color
    @property
    def coord(self):
        return self.__coord
    @coord.setter
    def coord(self, value = None):
        self.__coord = [value]
    def setCoord(self, coord = None):
        self.__coord = [coord]
        return self
    def addCoord(self, coord = None):
        if self.__coord == None:            self.__coord =  []
        self.__coord +=  [coord]
        return self
    def removeCoord(self, coord):
        self.__coord = [x for x in self.__coord if x not in coord]
        return self.__coord
    def getCoord(self, coord = None):
        return self.__coord
    def coord_changed(self, coord = None):
        return self.__coord
    @property
    def fogCoord(self):
        return self.__fogCoord
    @fogCoord.setter
    def fogCoord(self, value = None):
        self.__fogCoord = [value]
    def setFogCoord(self, fogCoord = None):
        self.__fogCoord = [fogCoord]
        return self
    def addFogCoord(self, fogCoord = None):
        if self.__fogCoord == None:            self.__fogCoord =  []
        self.__fogCoord +=  [fogCoord]
        return self
    def removeFogCoord(self, fogCoord):
        self.__fogCoord = [x for x in self.__fogCoord if x not in fogCoord]
        return self.__fogCoord
    def getFogCoord(self, fogCoord = None):
        return self.__fogCoord
    def fogCoord_changed(self, fogCoord = None):
        return self.__fogCoord
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def normal(self):
        return self.__normal
    @normal.setter
    def normal(self, value = None):
        self.__normal = [value]
    def setNormal(self, normal = None):
        self.__normal = [normal]
        return self
    def addNormal(self, normal = None):
        if self.__normal == None:            self.__normal =  []
        self.__normal +=  [normal]
        return self
    def removeNormal(self, normal):
        self.__normal = [x for x in self.__normal if x not in normal]
        return self.__normal
    def getNormal(self, normal = None):
        return self.__normal
    def normal_changed(self, normal = None):
        return self.__normal
    @property
    def index(self):
        return self.__index
    @index.setter
    def index(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        self.__index = [value]
    def set_index(self, index = None):
        if index == None or len(index) <= 0 or min(index)  <  0:
            return None
        self.__index = [index]
        return self
    @property
    def texCoord(self):
        return self.__texCoord
    @texCoord.setter
    def texCoord(self, value = None):
        self.__texCoord = [value]
    def setTexCoord(self, texCoord = None):
        self.__texCoord = [texCoord]
        return self
    def addTexCoord(self, texCoord = None):
        if self.__texCoord == None:            self.__texCoord =  []
        self.__texCoord +=  [texCoord]
        return self
    def removeTexCoord(self, texCoord):
        self.__texCoord = [x for x in self.__texCoord if x not in texCoord]
        return self.__texCoord
    def getTexCoord(self, texCoord = None):
        return self.__texCoord
    def texCoord_changed(self, texCoord = None):
        return self.__texCoord
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<IndexedQuadSet'
        if self.__ccw is not None:
            if isinstance(self.__ccw, six.string_types):
                str += ' ccw="'+self.__ccw+'"'
            else:
                str += ' ccw="'+self.__ccw[0]+'"'
        if self.__colorPerVertex is not None:
            if isinstance(self.__colorPerVertex, six.string_types):
                str += ' colorPerVertex="'+self.__colorPerVertex+'"'
            else:
                str += ' colorPerVertex="'+self.__colorPerVertex[0]+'"'
        if self.__index is not None:
            if isinstance(self.__index, six.string_types):
                str += ' index="'+self.__index+'"'
            else:
                str += ' index="'+self.__index[0]+'"'
        if self.__normalPerVertex is not None:
            if isinstance(self.__normalPerVertex, six.string_types):
                str += ' normalPerVertex="'+self.__normalPerVertex+'"'
            else:
                str += ' normalPerVertex="'+self.__normalPerVertex[0]+'"'
        if self.__index is not None:
            if isinstance(self.__index, six.string_types):
                str += ' index="'+self.__index+'"'
            else:
                str += ' index="'+self.__index[0]+'"'
        if self.__solid is not None:
            if isinstance(self.__solid, six.string_types):
                str += ' solid="'+self.__solid+'"'
            else:
                str += ' solid="'+self.__solid[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<attrib'
        if self.__attrib is not None:
           for s in self.__attrib:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__attrib is not None:
           for s in self.__attrib:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</attrib>'
        str += '<color'
        if self.__color is not None:
           for s in self.__color:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__color is not None:
           for s in self.__color:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</color>'
        str += '<coord'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</coord>'
        str += '<fogCoord'
        if self.__fogCoord is not None:
           for s in self.__fogCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__fogCoord is not None:
           for s in self.__fogCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</fogCoord>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<normal'
        if self.__normal is not None:
           for s in self.__normal:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__normal is not None:
           for s in self.__normal:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</normal>'
        str += '<texCoord'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</texCoord>'
        str += '</IndexedQuadSet>'
        return str


class IndexedTriangleFanSet(X3DComposedGeometryNode):
    def __init__(self, **kwargs):
        super(IndexedTriangleFanSet, self).__init__(**kwargs)
        attrib  = kwargs.pop("attrib", None)
        self.__attrib = attrib
        ccw  = kwargs.pop("ccw", True)
        self.__ccw = ccw
        color  = kwargs.pop("color", None)
        self.__color = color
        colorPerVertex  = kwargs.pop("colorPerVertex", True)
        self.__colorPerVertex = colorPerVertex
        coord  = kwargs.pop("coord", None)
        self.__coord = coord
        fogCoord  = kwargs.pop("fogCoord", None)
        self.__fogCoord = fogCoord
        index  = kwargs.pop("index", None)
        if index == None or len(index) <= 0 or min(index)  <  -1:
            return None
        self.__index = index
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        normal  = kwargs.pop("normal", None)
        self.__normal = normal
        normalPerVertex  = kwargs.pop("normalPerVertex", True)
        self.__normalPerVertex = normalPerVertex
        index  = kwargs.pop("index", None)
        if index == None or len(index) <= 0 or min(index)  <  -1:
            return None
        self.__index = index
        solid  = kwargs.pop("solid", True)
        self.__solid = solid
        texCoord  = kwargs.pop("texCoord", None)
        self.__texCoord = texCoord
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def attrib(self):
        return self.__attrib
    @attrib.setter
    def attrib(self, value = None):
        self.__attrib = [value]
    def setAttrib(self, attrib = None):
        self.__attrib = [attrib]
        return self
    def addAttrib(self, attrib = None):
        if self.__attrib == None:            self.__attrib =  []
        self.__attrib +=  [attrib]
        return self
    def removeAttrib(self, attrib):
        self.__attrib = [x for x in self.__attrib if x not in attrib]
        return self.__attrib
    def getAttrib(self, attrib = None):
        return self.__attrib
    def attrib_changed(self, attrib = None):
        return self.__attrib
    @property
    def color(self):
        return self.__color
    @color.setter
    def color(self, value = None):
        self.__color = [value]
    def setColor(self, color = None):
        self.__color = [color]
        return self
    def addColor(self, color = None):
        if self.__color == None:            self.__color =  []
        self.__color +=  [color]
        return self
    def removeColor(self, color):
        self.__color = [x for x in self.__color if x not in color]
        return self.__color
    def getColor(self, color = None):
        return self.__color
    def color_changed(self, color = None):
        return self.__color
    @property
    def coord(self):
        return self.__coord
    @coord.setter
    def coord(self, value = None):
        self.__coord = [value]
    def setCoord(self, coord = None):
        self.__coord = [coord]
        return self
    def addCoord(self, coord = None):
        if self.__coord == None:            self.__coord =  []
        self.__coord +=  [coord]
        return self
    def removeCoord(self, coord):
        self.__coord = [x for x in self.__coord if x not in coord]
        return self.__coord
    def getCoord(self, coord = None):
        return self.__coord
    def coord_changed(self, coord = None):
        return self.__coord
    @property
    def fogCoord(self):
        return self.__fogCoord
    @fogCoord.setter
    def fogCoord(self, value = None):
        self.__fogCoord = [value]
    def setFogCoord(self, fogCoord = None):
        self.__fogCoord = [fogCoord]
        return self
    def addFogCoord(self, fogCoord = None):
        if self.__fogCoord == None:            self.__fogCoord =  []
        self.__fogCoord +=  [fogCoord]
        return self
    def removeFogCoord(self, fogCoord):
        self.__fogCoord = [x for x in self.__fogCoord if x not in fogCoord]
        return self.__fogCoord
    def getFogCoord(self, fogCoord = None):
        return self.__fogCoord
    def fogCoord_changed(self, fogCoord = None):
        return self.__fogCoord
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def normal(self):
        return self.__normal
    @normal.setter
    def normal(self, value = None):
        self.__normal = [value]
    def setNormal(self, normal = None):
        self.__normal = [normal]
        return self
    def addNormal(self, normal = None):
        if self.__normal == None:            self.__normal =  []
        self.__normal +=  [normal]
        return self
    def removeNormal(self, normal):
        self.__normal = [x for x in self.__normal if x not in normal]
        return self.__normal
    def getNormal(self, normal = None):
        return self.__normal
    def normal_changed(self, normal = None):
        return self.__normal
    @property
    def index(self):
        return self.__index
    @index.setter
    def index(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  -1:
            return None
        self.__index = [value]
    def set_index(self, index = None):
        if index == None or len(index) <= 0 or min(index)  <  -1:
            return None
        self.__index = [index]
        return self
    @property
    def texCoord(self):
        return self.__texCoord
    @texCoord.setter
    def texCoord(self, value = None):
        self.__texCoord = [value]
    def setTexCoord(self, texCoord = None):
        self.__texCoord = [texCoord]
        return self
    def addTexCoord(self, texCoord = None):
        if self.__texCoord == None:            self.__texCoord =  []
        self.__texCoord +=  [texCoord]
        return self
    def removeTexCoord(self, texCoord):
        self.__texCoord = [x for x in self.__texCoord if x not in texCoord]
        return self.__texCoord
    def getTexCoord(self, texCoord = None):
        return self.__texCoord
    def texCoord_changed(self, texCoord = None):
        return self.__texCoord
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<IndexedTriangleFanSet'
        if self.__ccw is not None:
            if isinstance(self.__ccw, six.string_types):
                str += ' ccw="'+self.__ccw+'"'
            else:
                str += ' ccw="'+self.__ccw[0]+'"'
        if self.__colorPerVertex is not None:
            if isinstance(self.__colorPerVertex, six.string_types):
                str += ' colorPerVertex="'+self.__colorPerVertex+'"'
            else:
                str += ' colorPerVertex="'+self.__colorPerVertex[0]+'"'
        if self.__index is not None:
            if isinstance(self.__index, six.string_types):
                str += ' index="'+self.__index+'"'
            else:
                str += ' index="'+self.__index[0]+'"'
        if self.__normalPerVertex is not None:
            if isinstance(self.__normalPerVertex, six.string_types):
                str += ' normalPerVertex="'+self.__normalPerVertex+'"'
            else:
                str += ' normalPerVertex="'+self.__normalPerVertex[0]+'"'
        if self.__index is not None:
            if isinstance(self.__index, six.string_types):
                str += ' index="'+self.__index+'"'
            else:
                str += ' index="'+self.__index[0]+'"'
        if self.__solid is not None:
            if isinstance(self.__solid, six.string_types):
                str += ' solid="'+self.__solid+'"'
            else:
                str += ' solid="'+self.__solid[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<attrib'
        if self.__attrib is not None:
           for s in self.__attrib:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__attrib is not None:
           for s in self.__attrib:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</attrib>'
        str += '<color'
        if self.__color is not None:
           for s in self.__color:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__color is not None:
           for s in self.__color:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</color>'
        str += '<coord'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</coord>'
        str += '<fogCoord'
        if self.__fogCoord is not None:
           for s in self.__fogCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__fogCoord is not None:
           for s in self.__fogCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</fogCoord>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<normal'
        if self.__normal is not None:
           for s in self.__normal:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__normal is not None:
           for s in self.__normal:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</normal>'
        str += '<texCoord'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</texCoord>'
        str += '</IndexedTriangleFanSet>'
        return str


class IndexedTriangleSet(X3DComposedGeometryNode):
    def __init__(self, **kwargs):
        super(IndexedTriangleSet, self).__init__(**kwargs)
        attrib  = kwargs.pop("attrib", None)
        self.__attrib = attrib
        ccw  = kwargs.pop("ccw", True)
        self.__ccw = ccw
        color  = kwargs.pop("color", None)
        self.__color = color
        colorPerVertex  = kwargs.pop("colorPerVertex", True)
        self.__colorPerVertex = colorPerVertex
        coord  = kwargs.pop("coord", None)
        self.__coord = coord
        fogCoord  = kwargs.pop("fogCoord", None)
        self.__fogCoord = fogCoord
        index  = kwargs.pop("index", None)
        if index == None or len(index) <= 0 or min(index)  <  0:
            return None
        self.__index = index
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        normal  = kwargs.pop("normal", None)
        self.__normal = normal
        normalPerVertex  = kwargs.pop("normalPerVertex", True)
        self.__normalPerVertex = normalPerVertex
        index  = kwargs.pop("index", None)
        if index == None or len(index) <= 0 or min(index)  <  0:
            return None
        self.__index = index
        solid  = kwargs.pop("solid", True)
        self.__solid = solid
        texCoord  = kwargs.pop("texCoord", None)
        self.__texCoord = texCoord
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def attrib(self):
        return self.__attrib
    @attrib.setter
    def attrib(self, value = None):
        self.__attrib = [value]
    def setAttrib(self, attrib = None):
        self.__attrib = [attrib]
        return self
    def addAttrib(self, attrib = None):
        if self.__attrib == None:            self.__attrib =  []
        self.__attrib +=  [attrib]
        return self
    def removeAttrib(self, attrib):
        self.__attrib = [x for x in self.__attrib if x not in attrib]
        return self.__attrib
    def getAttrib(self, attrib = None):
        return self.__attrib
    def attrib_changed(self, attrib = None):
        return self.__attrib
    @property
    def color(self):
        return self.__color
    @color.setter
    def color(self, value = None):
        self.__color = [value]
    def setColor(self, color = None):
        self.__color = [color]
        return self
    def addColor(self, color = None):
        if self.__color == None:            self.__color =  []
        self.__color +=  [color]
        return self
    def removeColor(self, color):
        self.__color = [x for x in self.__color if x not in color]
        return self.__color
    def getColor(self, color = None):
        return self.__color
    def color_changed(self, color = None):
        return self.__color
    @property
    def coord(self):
        return self.__coord
    @coord.setter
    def coord(self, value = None):
        self.__coord = [value]
    def setCoord(self, coord = None):
        self.__coord = [coord]
        return self
    def addCoord(self, coord = None):
        if self.__coord == None:            self.__coord =  []
        self.__coord +=  [coord]
        return self
    def removeCoord(self, coord):
        self.__coord = [x for x in self.__coord if x not in coord]
        return self.__coord
    def getCoord(self, coord = None):
        return self.__coord
    def coord_changed(self, coord = None):
        return self.__coord
    @property
    def fogCoord(self):
        return self.__fogCoord
    @fogCoord.setter
    def fogCoord(self, value = None):
        self.__fogCoord = [value]
    def setFogCoord(self, fogCoord = None):
        self.__fogCoord = [fogCoord]
        return self
    def addFogCoord(self, fogCoord = None):
        if self.__fogCoord == None:            self.__fogCoord =  []
        self.__fogCoord +=  [fogCoord]
        return self
    def removeFogCoord(self, fogCoord):
        self.__fogCoord = [x for x in self.__fogCoord if x not in fogCoord]
        return self.__fogCoord
    def getFogCoord(self, fogCoord = None):
        return self.__fogCoord
    def fogCoord_changed(self, fogCoord = None):
        return self.__fogCoord
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def normal(self):
        return self.__normal
    @normal.setter
    def normal(self, value = None):
        self.__normal = [value]
    def setNormal(self, normal = None):
        self.__normal = [normal]
        return self
    def addNormal(self, normal = None):
        if self.__normal == None:            self.__normal =  []
        self.__normal +=  [normal]
        return self
    def removeNormal(self, normal):
        self.__normal = [x for x in self.__normal if x not in normal]
        return self.__normal
    def getNormal(self, normal = None):
        return self.__normal
    def normal_changed(self, normal = None):
        return self.__normal
    @property
    def index(self):
        return self.__index
    @index.setter
    def index(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        self.__index = [value]
    def set_index(self, index = None):
        if index == None or len(index) <= 0 or min(index)  <  0:
            return None
        self.__index = [index]
        return self
    @property
    def texCoord(self):
        return self.__texCoord
    @texCoord.setter
    def texCoord(self, value = None):
        self.__texCoord = [value]
    def setTexCoord(self, texCoord = None):
        self.__texCoord = [texCoord]
        return self
    def addTexCoord(self, texCoord = None):
        if self.__texCoord == None:            self.__texCoord =  []
        self.__texCoord +=  [texCoord]
        return self
    def removeTexCoord(self, texCoord):
        self.__texCoord = [x for x in self.__texCoord if x not in texCoord]
        return self.__texCoord
    def getTexCoord(self, texCoord = None):
        return self.__texCoord
    def texCoord_changed(self, texCoord = None):
        return self.__texCoord
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<IndexedTriangleSet'
        if self.__ccw is not None:
            if isinstance(self.__ccw, six.string_types):
                str += ' ccw="'+self.__ccw+'"'
            else:
                str += ' ccw="'+self.__ccw[0]+'"'
        if self.__colorPerVertex is not None:
            if isinstance(self.__colorPerVertex, six.string_types):
                str += ' colorPerVertex="'+self.__colorPerVertex+'"'
            else:
                str += ' colorPerVertex="'+self.__colorPerVertex[0]+'"'
        if self.__index is not None:
            if isinstance(self.__index, six.string_types):
                str += ' index="'+self.__index+'"'
            else:
                str += ' index="'+self.__index[0]+'"'
        if self.__normalPerVertex is not None:
            if isinstance(self.__normalPerVertex, six.string_types):
                str += ' normalPerVertex="'+self.__normalPerVertex+'"'
            else:
                str += ' normalPerVertex="'+self.__normalPerVertex[0]+'"'
        if self.__index is not None:
            if isinstance(self.__index, six.string_types):
                str += ' index="'+self.__index+'"'
            else:
                str += ' index="'+self.__index[0]+'"'
        if self.__solid is not None:
            if isinstance(self.__solid, six.string_types):
                str += ' solid="'+self.__solid+'"'
            else:
                str += ' solid="'+self.__solid[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<attrib'
        if self.__attrib is not None:
           for s in self.__attrib:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__attrib is not None:
           for s in self.__attrib:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</attrib>'
        str += '<color'
        if self.__color is not None:
           for s in self.__color:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__color is not None:
           for s in self.__color:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</color>'
        str += '<coord'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</coord>'
        str += '<fogCoord'
        if self.__fogCoord is not None:
           for s in self.__fogCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__fogCoord is not None:
           for s in self.__fogCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</fogCoord>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<normal'
        if self.__normal is not None:
           for s in self.__normal:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__normal is not None:
           for s in self.__normal:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</normal>'
        str += '<texCoord'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</texCoord>'
        str += '</IndexedTriangleSet>'
        return str


class IndexedTriangleStripSet(X3DComposedGeometryNode):
    def __init__(self, **kwargs):
        super(IndexedTriangleStripSet, self).__init__(**kwargs)
        attrib  = kwargs.pop("attrib", None)
        self.__attrib = attrib
        ccw  = kwargs.pop("ccw", True)
        self.__ccw = ccw
        color  = kwargs.pop("color", None)
        self.__color = color
        colorPerVertex  = kwargs.pop("colorPerVertex", True)
        self.__colorPerVertex = colorPerVertex
        coord  = kwargs.pop("coord", None)
        self.__coord = coord
        fogCoord  = kwargs.pop("fogCoord", None)
        self.__fogCoord = fogCoord
        index  = kwargs.pop("index", None)
        if index == None or len(index) <= 0 or min(index)  <  -1:
            return None
        self.__index = index
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        normal  = kwargs.pop("normal", None)
        self.__normal = normal
        normalPerVertex  = kwargs.pop("normalPerVertex", True)
        self.__normalPerVertex = normalPerVertex
        index  = kwargs.pop("index", None)
        if index == None or len(index) <= 0 or min(index)  <  -1:
            return None
        self.__index = index
        solid  = kwargs.pop("solid", True)
        self.__solid = solid
        texCoord  = kwargs.pop("texCoord", None)
        self.__texCoord = texCoord
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def attrib(self):
        return self.__attrib
    @attrib.setter
    def attrib(self, value = None):
        self.__attrib = [value]
    def setAttrib(self, attrib = None):
        self.__attrib = [attrib]
        return self
    def addAttrib(self, attrib = None):
        if self.__attrib == None:            self.__attrib =  []
        self.__attrib +=  [attrib]
        return self
    def removeAttrib(self, attrib):
        self.__attrib = [x for x in self.__attrib if x not in attrib]
        return self.__attrib
    def getAttrib(self, attrib = None):
        return self.__attrib
    def attrib_changed(self, attrib = None):
        return self.__attrib
    @property
    def color(self):
        return self.__color
    @color.setter
    def color(self, value = None):
        self.__color = [value]
    def setColor(self, color = None):
        self.__color = [color]
        return self
    def addColor(self, color = None):
        if self.__color == None:            self.__color =  []
        self.__color +=  [color]
        return self
    def removeColor(self, color):
        self.__color = [x for x in self.__color if x not in color]
        return self.__color
    def getColor(self, color = None):
        return self.__color
    def color_changed(self, color = None):
        return self.__color
    @property
    def coord(self):
        return self.__coord
    @coord.setter
    def coord(self, value = None):
        self.__coord = [value]
    def setCoord(self, coord = None):
        self.__coord = [coord]
        return self
    def addCoord(self, coord = None):
        if self.__coord == None:            self.__coord =  []
        self.__coord +=  [coord]
        return self
    def removeCoord(self, coord):
        self.__coord = [x for x in self.__coord if x not in coord]
        return self.__coord
    def getCoord(self, coord = None):
        return self.__coord
    def coord_changed(self, coord = None):
        return self.__coord
    @property
    def fogCoord(self):
        return self.__fogCoord
    @fogCoord.setter
    def fogCoord(self, value = None):
        self.__fogCoord = [value]
    def setFogCoord(self, fogCoord = None):
        self.__fogCoord = [fogCoord]
        return self
    def addFogCoord(self, fogCoord = None):
        if self.__fogCoord == None:            self.__fogCoord =  []
        self.__fogCoord +=  [fogCoord]
        return self
    def removeFogCoord(self, fogCoord):
        self.__fogCoord = [x for x in self.__fogCoord if x not in fogCoord]
        return self.__fogCoord
    def getFogCoord(self, fogCoord = None):
        return self.__fogCoord
    def fogCoord_changed(self, fogCoord = None):
        return self.__fogCoord
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def normal(self):
        return self.__normal
    @normal.setter
    def normal(self, value = None):
        self.__normal = [value]
    def setNormal(self, normal = None):
        self.__normal = [normal]
        return self
    def addNormal(self, normal = None):
        if self.__normal == None:            self.__normal =  []
        self.__normal +=  [normal]
        return self
    def removeNormal(self, normal):
        self.__normal = [x for x in self.__normal if x not in normal]
        return self.__normal
    def getNormal(self, normal = None):
        return self.__normal
    def normal_changed(self, normal = None):
        return self.__normal
    @property
    def index(self):
        return self.__index
    @index.setter
    def index(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  -1:
            return None
        self.__index = [value]
    def set_index(self, index = None):
        if index == None or len(index) <= 0 or min(index)  <  -1:
            return None
        self.__index = [index]
        return self
    @property
    def texCoord(self):
        return self.__texCoord
    @texCoord.setter
    def texCoord(self, value = None):
        self.__texCoord = [value]
    def setTexCoord(self, texCoord = None):
        self.__texCoord = [texCoord]
        return self
    def addTexCoord(self, texCoord = None):
        if self.__texCoord == None:            self.__texCoord =  []
        self.__texCoord +=  [texCoord]
        return self
    def removeTexCoord(self, texCoord):
        self.__texCoord = [x for x in self.__texCoord if x not in texCoord]
        return self.__texCoord
    def getTexCoord(self, texCoord = None):
        return self.__texCoord
    def texCoord_changed(self, texCoord = None):
        return self.__texCoord
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<IndexedTriangleStripSet'
        if self.__ccw is not None:
            if isinstance(self.__ccw, six.string_types):
                str += ' ccw="'+self.__ccw+'"'
            else:
                str += ' ccw="'+self.__ccw[0]+'"'
        if self.__colorPerVertex is not None:
            if isinstance(self.__colorPerVertex, six.string_types):
                str += ' colorPerVertex="'+self.__colorPerVertex+'"'
            else:
                str += ' colorPerVertex="'+self.__colorPerVertex[0]+'"'
        if self.__index is not None:
            if isinstance(self.__index, six.string_types):
                str += ' index="'+self.__index+'"'
            else:
                str += ' index="'+self.__index[0]+'"'
        if self.__normalPerVertex is not None:
            if isinstance(self.__normalPerVertex, six.string_types):
                str += ' normalPerVertex="'+self.__normalPerVertex+'"'
            else:
                str += ' normalPerVertex="'+self.__normalPerVertex[0]+'"'
        if self.__index is not None:
            if isinstance(self.__index, six.string_types):
                str += ' index="'+self.__index+'"'
            else:
                str += ' index="'+self.__index[0]+'"'
        if self.__solid is not None:
            if isinstance(self.__solid, six.string_types):
                str += ' solid="'+self.__solid+'"'
            else:
                str += ' solid="'+self.__solid[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<attrib'
        if self.__attrib is not None:
           for s in self.__attrib:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__attrib is not None:
           for s in self.__attrib:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</attrib>'
        str += '<color'
        if self.__color is not None:
           for s in self.__color:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__color is not None:
           for s in self.__color:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</color>'
        str += '<coord'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</coord>'
        str += '<fogCoord'
        if self.__fogCoord is not None:
           for s in self.__fogCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__fogCoord is not None:
           for s in self.__fogCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</fogCoord>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<normal'
        if self.__normal is not None:
           for s in self.__normal:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__normal is not None:
           for s in self.__normal:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</normal>'
        str += '<texCoord'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</texCoord>'
        str += '</IndexedTriangleStripSet>'
        return str


class Inline(X3DBoundedObject, X3DUrlObject, X3DChildNode):
    def __init__(self, **kwargs):
        super(Inline, self).__init__(**kwargs)
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        load  = kwargs.pop("load", True)
        self.__load = load
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        url  = kwargs.pop("url", None)
        self.__url = url
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def load(self):
        return self.__load
    @load.setter
    def load(self, value = True):
        self.__load = [value]
    def setLoad(self, load = True):
        self.__load = [load]
        return self
    def addLoad(self, load = True):
        if self.__load == None:            self.__load =  []
        self.__load +=  [load]
        return self
    def removeLoad(self, load):
        self.__load = [x for x in self.__load if x not in load]
        return self.__load
    def isLoad(self, load = True):
        return self.__load
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def url(self):
        return self.__url
    @url.setter
    def url(self, value = None):
        self.__url = [value]
    def setUrl(self, url = None):
        self.__url = [url]
        return self
    def addUrl(self, url = None):
        if self.__url == None:            self.__url =  []
        self.__url +=  [url]
        return self
    def removeUrl(self, url):
        self.__url = [x for x in self.__url if x not in url]
        return self.__url
    def getUrl(self, url = None):
        return self.__url
    def url_changed(self, url = None):
        return self.__url
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Inline'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__load is not None:
            if isinstance(self.__load, six.string_types):
                str += ' load="'+self.__load+'"'
            else:
                str += ' load="'+self.__load[0]+'"'
        if self.__url is not None:
            if isinstance(self.__url, six.string_types):
                str += ' url="'+self.__url+'"'
            else:
                str += ' url="'+self.__url[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</Inline>'
        return str


class IntegerSequencer(X3DSequencerNode):
    def __init__(self, **kwargs):
        super(IntegerSequencer, self).__init__(**kwargs)
        key  = kwargs.pop("key", None)
        self.__key = key
        keyValue  = kwargs.pop("keyValue", None)
        self.__keyValue = keyValue
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        next  = kwargs.pop("next", None)
        self.__next = next
        previous  = kwargs.pop("previous", None)
        self.__previous = previous
        fraction  = kwargs.pop("fraction", None)
        self.__fraction = fraction
        value_changed  = kwargs.pop("value_changed", None)
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def key(self):
        return self.__key
    @key.setter
    def key(self, value = None):
        self.__key = [value]
    def setKey(self, key = None):
        self.__key = [key]
        return self
    def addKey(self, key = None):
        if self.__key == None:            self.__key =  []
        self.__key +=  [key]
        return self
    def removeKey(self, key):
        self.__key = [x for x in self.__key if x not in key]
        return self.__key
    def getKey(self, key = None):
        return self.__key
    def key_changed(self, key = None):
        return self.__key
    @property
    def keyValue(self):
        return self.__keyValue
    @keyValue.setter
    def keyValue(self, value = None):
        self.__keyValue = [value]
    def setKeyValue(self, keyValue = None):
        self.__keyValue = [keyValue]
        return self
    def addKeyValue(self, keyValue = None):
        if self.__keyValue == None:            self.__keyValue =  []
        self.__keyValue +=  [keyValue]
        return self
    def removeKeyValue(self, keyValue):
        self.__keyValue = [x for x in self.__keyValue if x not in keyValue]
        return self.__keyValue
    def getKeyValue(self, keyValue = None):
        return self.__keyValue
    def keyValue_changed(self, keyValue = None):
        return self.__keyValue
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def next(self):
        return self.__next
    @next.setter
    def next(self, value = None):
        self.__next = [value]
    def setNext(self, next = None):
        self.__next = [next]
        return self
    def addNext(self, next = None):
        if self.__next == None:            self.__next =  []
        self.__next +=  [next]
        return self
    @property
    def previous(self):
        return self.__previous
    @previous.setter
    def previous(self, value = None):
        self.__previous = [value]
    def setPrevious(self, previous = None):
        self.__previous = [previous]
        return self
    def addPrevious(self, previous = None):
        if self.__previous == None:            self.__previous =  []
        self.__previous +=  [previous]
        return self
    @property
    def fraction(self):
        return self.__fraction
    @fraction.setter
    def fraction(self, value = None):
        self.__fraction = [value]
    def set_fraction(self, fraction = None):
        self.__fraction = [fraction]
        return self
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<IntegerSequencer'
        if self.__key is not None:
            if isinstance(self.__key, six.string_types):
                str += ' key="'+self.__key+'"'
            else:
                str += ' key="'+self.__key[0]+'"'
        if self.__keyValue is not None:
            if isinstance(self.__keyValue, six.string_types):
                str += ' keyValue="'+self.__keyValue+'"'
            else:
                str += ' keyValue="'+self.__keyValue[0]+'"'
        if self.__next is not None:
            if isinstance(self.__next, six.string_types):
                str += ' next="'+self.__next+'"'
            else:
                str += ' next="'+self.__next[0]+'"'
        if self.__previous is not None:
            if isinstance(self.__previous, six.string_types):
                str += ' previous="'+self.__previous+'"'
            else:
                str += ' previous="'+self.__previous[0]+'"'
        if self.__fraction is not None:
            if isinstance(self.__fraction, six.string_types):
                str += ' fraction="'+self.__fraction+'"'
            else:
                str += ' fraction="'+self.__fraction[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</IntegerSequencer>'
        return str


class IntegerTrigger(X3DTriggerNode):
    def __init__(self, **kwargs):
        super(IntegerTrigger, self).__init__(**kwargs)
        integerKey  = kwargs.pop("integerKey", -1)
        self.__integerKey = integerKey
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        boolean  = kwargs.pop("boolean", None)
        self.__boolean = boolean
        triggerValue  = kwargs.pop("triggerValue", None)
        self.__triggerValue = triggerValue
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def integerKey(self):
        return self.__integerKey
    @integerKey.setter
    def integerKey(self, value = -1):
        self.__integerKey = [value]
    def setIntegerKey(self, integerKey = -1):
        self.__integerKey = [integerKey]
        return self
    def addIntegerKey(self, integerKey = -1):
        if self.__integerKey == None:            self.__integerKey =  []
        self.__integerKey +=  [integerKey]
        return self
    def removeIntegerKey(self, integerKey):
        self.__integerKey = [x for x in self.__integerKey if x not in integerKey]
        return self.__integerKey
    def getIntegerKey(self, integerKey = -1):
        return self.__integerKey
    def integerKey_changed(self, integerKey = -1):
        return self.__integerKey
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def boolean(self):
        return self.__boolean
    @boolean.setter
    def boolean(self, value = None):
        self.__boolean = [value]
    def set_boolean(self, boolean = None):
        self.__boolean = [boolean]
        return self
    def removeTriggerValue(self, triggerValue):
        self.__triggerValue = [x for x in self.__triggerValue if x not in triggerValue]
        return self.__triggerValue
    def getTriggerValue(self, triggerValue = None):
        return self.__triggerValue
    def triggerValue_changed(self, triggerValue = None):
        return self.__triggerValue
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<IntegerTrigger'
        if self.__integerKey is not None:
            if isinstance(self.__integerKey, six.string_types):
                str += ' integerKey="'+self.__integerKey+'"'
            else:
                str += ' integerKey="'+self.__integerKey[0]+'"'
        if self.__boolean is not None:
            if isinstance(self.__boolean, six.string_types):
                str += ' boolean="'+self.__boolean+'"'
            else:
                str += ' boolean="'+self.__boolean[0]+'"'
        if self.__triggerValue is not None:
            if isinstance(self.__triggerValue, six.string_types):
                str += ' triggerValue="'+self.__triggerValue+'"'
            else:
                str += ' triggerValue="'+self.__triggerValue[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</IntegerTrigger>'
        return str


class IsoSurfaceVolumeData(X3DVolumeDataNode):
    def __init__(self, **kwargs):
        super(IsoSurfaceVolumeData, self).__init__(**kwargs)
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        contourStepSize  = kwargs.pop("contourStepSize", 0)
        self.__contourStepSize = contourStepSize
        dimensions  = kwargs.pop("dimensions", [1, 1, 1])
        if dimensions == None or len(dimensions) <= 0 or min(dimensions)  <=  0:
            return None
        self.__dimensions = dimensions
        gradients  = kwargs.pop("gradients", None)
        self.__gradients = gradients
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        renderStyle  = kwargs.pop("renderStyle", None)
        self.__renderStyle = renderStyle
        surfaceTolerance  = kwargs.pop("surfaceTolerance", 0)
        if surfaceTolerance == None or surfaceTolerance  <  0:
            return None
        self.__surfaceTolerance = surfaceTolerance
        surfaceValues  = kwargs.pop("surfaceValues", None)
        self.__surfaceValues = surfaceValues
        voxels  = kwargs.pop("voxels", None)
        self.__voxels = voxels
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def contourStepSize(self):
        return self.__contourStepSize
    @contourStepSize.setter
    def contourStepSize(self, value = 0):
        self.__contourStepSize = [value]
    def setContourStepSize(self, contourStepSize = 0):
        self.__contourStepSize = [contourStepSize]
        return self
    def addContourStepSize(self, contourStepSize = 0):
        if self.__contourStepSize == None:            self.__contourStepSize =  []
        self.__contourStepSize +=  [contourStepSize]
        return self
    def removeContourStepSize(self, contourStepSize):
        self.__contourStepSize = [x for x in self.__contourStepSize if x not in contourStepSize]
        return self.__contourStepSize
    def getContourStepSize(self, contourStepSize = 0):
        return self.__contourStepSize
    def contourStepSize_changed(self, contourStepSize = 0):
        return self.__contourStepSize
    @property
    def dimensions(self):
        return self.__dimensions
    @dimensions.setter
    def dimensions(self, value = [1, 1, 1]):
        if value == None or len(value) <= 0 or min(value)  <=  0:
            return None
        self.__dimensions = [value]
    def setDimensions(self, dimensions = [1, 1, 1]):
        if dimensions == None or len(dimensions) <= 0 or min(dimensions)  <=  0:
            return None
        self.__dimensions = [dimensions]
        return self
    def addDimensions(self, dimensions = [1, 1, 1]):
        if dimensions == None or len(dimensions) <= 0 or min(dimensions)  <=  0:
            return None
        if self.__dimensions == None:            self.__dimensions =  []
        self.__dimensions +=  [dimensions]
        return self
    def removeDimensions(self, dimensions):
        self.__dimensions = [x for x in self.__dimensions if x not in dimensions]
        return self.__dimensions
    def getDimensions(self, dimensions = [1, 1, 1]):
        return self.__dimensions
    def dimensions_changed(self, dimensions = [1, 1, 1]):
        return self.__dimensions
    @property
    def gradients(self):
        return self.__gradients
    @gradients.setter
    def gradients(self, value = None):
        self.__gradients = [value]
    def setGradients(self, gradients = None):
        self.__gradients = [gradients]
        return self
    def addGradients(self, gradients = None):
        if self.__gradients == None:            self.__gradients =  []
        self.__gradients +=  [gradients]
        return self
    def removeGradients(self, gradients):
        self.__gradients = [x for x in self.__gradients if x not in gradients]
        return self.__gradients
    def getGradients(self, gradients = None):
        return self.__gradients
    def gradients_changed(self, gradients = None):
        return self.__gradients
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def renderStyle(self):
        return self.__renderStyle
    @renderStyle.setter
    def renderStyle(self, value = None):
        self.__renderStyle = [value]
    def setRenderStyle(self, renderStyle = None):
        self.__renderStyle = [renderStyle]
        return self
    def addRenderStyle(self, renderStyle = None):
        if self.__renderStyle == None:            self.__renderStyle =  []
        self.__renderStyle +=  [renderStyle]
        return self
    def removeRenderStyle(self, renderStyle):
        self.__renderStyle = [x for x in self.__renderStyle if x not in renderStyle]
        return self.__renderStyle
    def getRenderStyle(self, renderStyle = None):
        return self.__renderStyle
    def renderStyle_changed(self, renderStyle = None):
        return self.__renderStyle
    @property
    def surfaceTolerance(self):
        return self.__surfaceTolerance
    @surfaceTolerance.setter
    def surfaceTolerance(self, value = 0):
        if value == None or value  <  0:
            return None
        self.__surfaceTolerance = [value]
    def setSurfaceTolerance(self, surfaceTolerance = 0):
        if surfaceTolerance == None or surfaceTolerance  <  0:
            return None
        self.__surfaceTolerance = [surfaceTolerance]
        return self
    def addSurfaceTolerance(self, surfaceTolerance = 0):
        if surfaceTolerance == None or surfaceTolerance  <  0:
            return None
        if self.__surfaceTolerance == None:            self.__surfaceTolerance =  []
        self.__surfaceTolerance +=  [surfaceTolerance]
        return self
    def removeSurfaceTolerance(self, surfaceTolerance):
        self.__surfaceTolerance = [x for x in self.__surfaceTolerance if x not in surfaceTolerance]
        return self.__surfaceTolerance
    def getSurfaceTolerance(self, surfaceTolerance = 0):
        return self.__surfaceTolerance
    def surfaceTolerance_changed(self, surfaceTolerance = 0):
        return self.__surfaceTolerance
    @property
    def surfaceValues(self):
        return self.__surfaceValues
    @surfaceValues.setter
    def surfaceValues(self, value = None):
        self.__surfaceValues = [value]
    def setSurfaceValues(self, surfaceValues = None):
        self.__surfaceValues = [surfaceValues]
        return self
    def addSurfaceValues(self, surfaceValues = None):
        if self.__surfaceValues == None:            self.__surfaceValues =  []
        self.__surfaceValues +=  [surfaceValues]
        return self
    def removeSurfaceValues(self, surfaceValues):
        self.__surfaceValues = [x for x in self.__surfaceValues if x not in surfaceValues]
        return self.__surfaceValues
    def getSurfaceValues(self, surfaceValues = None):
        return self.__surfaceValues
    def surfaceValues_changed(self, surfaceValues = None):
        return self.__surfaceValues
    @property
    def voxels(self):
        return self.__voxels
    @voxels.setter
    def voxels(self, value = None):
        self.__voxels = [value]
    def setVoxels(self, voxels = None):
        self.__voxels = [voxels]
        return self
    def addVoxels(self, voxels = None):
        if self.__voxels == None:            self.__voxels =  []
        self.__voxels +=  [voxels]
        return self
    def removeVoxels(self, voxels):
        self.__voxels = [x for x in self.__voxels if x not in voxels]
        return self.__voxels
    def getVoxels(self, voxels = None):
        return self.__voxels
    def voxels_changed(self, voxels = None):
        return self.__voxels
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<IsoSurfaceVolumeData'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__contourStepSize is not None:
            if isinstance(self.__contourStepSize, six.string_types):
                str += ' contourStepSize="'+self.__contourStepSize+'"'
            else:
                str += ' contourStepSize="'+self.__contourStepSize[0]+'"'
        if self.__dimensions is not None:
            if isinstance(self.__dimensions, six.string_types):
                str += ' dimensions="'+self.__dimensions+'"'
            else:
                str += ' dimensions="'+self.__dimensions[0]+'"'
        if self.__surfaceTolerance is not None:
            if isinstance(self.__surfaceTolerance, six.string_types):
                str += ' surfaceTolerance="'+self.__surfaceTolerance+'"'
            else:
                str += ' surfaceTolerance="'+self.__surfaceTolerance[0]+'"'
        if self.__surfaceValues is not None:
            if isinstance(self.__surfaceValues, six.string_types):
                str += ' surfaceValues="'+self.__surfaceValues+'"'
            else:
                str += ' surfaceValues="'+self.__surfaceValues[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<gradients'
        if self.__gradients is not None:
           for s in self.__gradients:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__gradients is not None:
           for s in self.__gradients:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</gradients>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<renderStyle'
        if self.__renderStyle is not None:
           for s in self.__renderStyle:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__renderStyle is not None:
           for s in self.__renderStyle:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</renderStyle>'
        str += '<voxels'
        if self.__voxels is not None:
           for s in self.__voxels:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__voxels is not None:
           for s in self.__voxels:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</voxels>'
        str += '</IsoSurfaceVolumeData>'
        return str


class KeySensor(X3DKeyDeviceSensorNode):
    def __init__(self, **kwargs):
        super(KeySensor, self).__init__(**kwargs)
        actionKeyPress  = kwargs.pop("actionKeyPress", None)
        self.__actionKeyPress = actionKeyPress
        actionKeyRelease  = kwargs.pop("actionKeyRelease", None)
        self.__actionKeyRelease = actionKeyRelease
        altKey  = kwargs.pop("altKey", None)
        self.__altKey = altKey
        controlKey  = kwargs.pop("controlKey", None)
        self.__controlKey = controlKey
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        keyPress  = kwargs.pop("keyPress", None)
        self.__keyPress = keyPress
        keyRelease  = kwargs.pop("keyRelease", None)
        self.__keyRelease = keyRelease
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        shiftKey  = kwargs.pop("shiftKey", None)
        self.__shiftKey = shiftKey
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def removeActionKeyPress(self, actionKeyPress):
        self.__actionKeyPress = [x for x in self.__actionKeyPress if x not in actionKeyPress]
        return self.__actionKeyPress
    def getActionKeyPress(self, actionKeyPress = None):
        return self.__actionKeyPress
    def actionKeyPress_changed(self, actionKeyPress = None):
        return self.__actionKeyPress
    def removeActionKeyRelease(self, actionKeyRelease):
        self.__actionKeyRelease = [x for x in self.__actionKeyRelease if x not in actionKeyRelease]
        return self.__actionKeyRelease
    def getActionKeyRelease(self, actionKeyRelease = None):
        return self.__actionKeyRelease
    def actionKeyRelease_changed(self, actionKeyRelease = None):
        return self.__actionKeyRelease
    def removeAltKey(self, altKey):
        self.__altKey = [x for x in self.__altKey if x not in altKey]
        return self.__altKey
    def isAltKey(self, altKey = None):
        return self.__altKey
    def removeControlKey(self, controlKey):
        self.__controlKey = [x for x in self.__controlKey if x not in controlKey]
        return self.__controlKey
    def isControlKey(self, controlKey = None):
        return self.__controlKey
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    def isActive(self, Active = None):
        return self.__Active
    def removeKeyPress(self, keyPress):
        self.__keyPress = [x for x in self.__keyPress if x not in keyPress]
        return self.__keyPress
    def getKeyPress(self, keyPress = None):
        return self.__keyPress
    def keyPress_changed(self, keyPress = None):
        return self.__keyPress
    def removeKeyRelease(self, keyRelease):
        self.__keyRelease = [x for x in self.__keyRelease if x not in keyRelease]
        return self.__keyRelease
    def getKeyRelease(self, keyRelease = None):
        return self.__keyRelease
    def keyRelease_changed(self, keyRelease = None):
        return self.__keyRelease
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    def removeShiftKey(self, shiftKey):
        self.__shiftKey = [x for x in self.__shiftKey if x not in shiftKey]
        return self.__shiftKey
    def isShiftKey(self, shiftKey = None):
        return self.__shiftKey
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<KeySensor'
        if self.__actionKeyPress is not None:
            if isinstance(self.__actionKeyPress, six.string_types):
                str += ' actionKeyPress="'+self.__actionKeyPress+'"'
            else:
                str += ' actionKeyPress="'+self.__actionKeyPress[0]+'"'
        if self.__actionKeyRelease is not None:
            if isinstance(self.__actionKeyRelease, six.string_types):
                str += ' actionKeyRelease="'+self.__actionKeyRelease+'"'
            else:
                str += ' actionKeyRelease="'+self.__actionKeyRelease[0]+'"'
        if self.__altKey is not None:
            if isinstance(self.__altKey, six.string_types):
                str += ' altKey="'+self.__altKey+'"'
            else:
                str += ' altKey="'+self.__altKey[0]+'"'
        if self.__controlKey is not None:
            if isinstance(self.__controlKey, six.string_types):
                str += ' controlKey="'+self.__controlKey+'"'
            else:
                str += ' controlKey="'+self.__controlKey[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__keyPress is not None:
            if isinstance(self.__keyPress, six.string_types):
                str += ' keyPress="'+self.__keyPress+'"'
            else:
                str += ' keyPress="'+self.__keyPress[0]+'"'
        if self.__keyRelease is not None:
            if isinstance(self.__keyRelease, six.string_types):
                str += ' keyRelease="'+self.__keyRelease+'"'
            else:
                str += ' keyRelease="'+self.__keyRelease[0]+'"'
        if self.__shiftKey is not None:
            if isinstance(self.__shiftKey, six.string_types):
                str += ' shiftKey="'+self.__shiftKey+'"'
            else:
                str += ' shiftKey="'+self.__shiftKey[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</KeySensor>'
        return str


class Layer(X3DLayerNode):
    def __init__(self, **kwargs):
        super(Layer, self).__init__(**kwargs)
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        children  = kwargs.pop("children", None)
        self.__children = children
        Pickable  = kwargs.pop("Pickable", True)
        self.__Pickable = Pickable
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        viewport  = kwargs.pop("viewport", None)
        self.__viewport = viewport
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    def addChildren(self, Children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [Children]
        return self
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    @property
    def Pickable(self):
        return self.__Pickable
    @Pickable.setter
    def Pickable(self, value = True):
        self.__Pickable = [value]
    def setIsPickable(self, Pickable = True):
        self.__Pickable = [Pickable]
        return self
    def addIsPickable(self, Pickable = True):
        if self.__Pickable == None:            self.__Pickable =  []
        self.__Pickable +=  [Pickable]
        return self
    def isPickable(self, Pickable = True):
        return self.__Pickable
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    @property
    def viewport(self):
        return self.__viewport
    @viewport.setter
    def viewport(self, value = None):
        self.__viewport = [value]
    def setViewport(self, viewport = None):
        self.__viewport = [viewport]
        return self
    def addViewport(self, viewport = None):
        if self.__viewport == None:            self.__viewport =  []
        self.__viewport +=  [viewport]
        return self
    def removeViewport(self, viewport):
        self.__viewport = [x for x in self.__viewport if x not in viewport]
        return self.__viewport
    def getViewport(self, viewport = None):
        return self.__viewport
    def viewport_changed(self, viewport = None):
        return self.__viewport
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Layer'
        if self.__Pickable is not None:
            if isinstance(self.__Pickable, six.string_types):
                str += ' Pickable="'+self.__Pickable+'"'
            else:
                str += ' Pickable="'+self.__Pickable[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '<viewport'
        if self.__viewport is not None:
           for s in self.__viewport:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__viewport is not None:
           for s in self.__viewport:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</viewport>'
        str += '</Layer>'
        return str


class LayerSet(X3DNode):
    def __init__(self, **kwargs):
        super(LayerSet, self).__init__(**kwargs)
        activeLayer  = kwargs.pop("activeLayer", 0)
        if activeLayer == None or activeLayer  <  0:
            return None
        self.__activeLayer = activeLayer
        layers  = kwargs.pop("layers", None)
        self.__layers = layers
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        order  = kwargs.pop("order", [0])
        if order == None or len(order) <= 0 or min(order)  <  0:
            return None
        self.__order = order
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def activeLayer(self):
        return self.__activeLayer
    @activeLayer.setter
    def activeLayer(self, value = 0):
        if value == None or value  <  0:
            return None
        self.__activeLayer = [value]
    def setActiveLayer(self, activeLayer = 0):
        if activeLayer == None or activeLayer  <  0:
            return None
        self.__activeLayer = [activeLayer]
        return self
    def addActiveLayer(self, activeLayer = 0):
        if activeLayer == None or activeLayer  <  0:
            return None
        if self.__activeLayer == None:            self.__activeLayer =  []
        self.__activeLayer +=  [activeLayer]
        return self
    def removeActiveLayer(self, activeLayer):
        self.__activeLayer = [x for x in self.__activeLayer if x not in activeLayer]
        return self.__activeLayer
    def getActiveLayer(self, activeLayer = 0):
        return self.__activeLayer
    def activeLayer_changed(self, activeLayer = 0):
        return self.__activeLayer
    @property
    def layers(self):
        return self.__layers
    @layers.setter
    def layers(self, value = None):
        self.__layers = [value]
    def setLayers(self, layers = None):
        self.__layers = [layers]
        return self
    def addLayers(self, layers = None):
        if self.__layers == None:            self.__layers =  []
        self.__layers +=  [layers]
        return self
    def removeLayers(self, layers):
        self.__layers = [x for x in self.__layers if x not in layers]
        return self.__layers
    def getLayers(self, layers = None):
        return self.__layers
    def layers_changed(self, layers = None):
        return self.__layers
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    @property
    def order(self):
        return self.__order
    @order.setter
    def order(self, value = None):
        self.__order = [value]
    def setOrder(self, order = None):
        self.__order = [order]
        return self
    def addOrder(self, order = None):
        if self.__order == None:            self.__order =  []
        self.__order +=  [order]
        return self
    def toXML(self):
        str = ''
        str += '<LayerSet'
        if self.__activeLayer is not None:
            if isinstance(self.__activeLayer, six.string_types):
                str += ' activeLayer="'+self.__activeLayer+'"'
            else:
                str += ' activeLayer="'+self.__activeLayer[0]+'"'
        if self.__order is not None:
            if isinstance(self.__order, six.string_types):
                str += ' order="'+self.__order+'"'
            else:
                str += ' order="'+self.__order[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<layers'
        if self.__layers is not None:
           for s in self.__layers:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__layers is not None:
           for s in self.__layers:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</layers>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</LayerSet>'
        return str


class Layout(X3DLayoutNode):
    def __init__(self, **kwargs):
        super(Layout, self).__init__(**kwargs)
        align  = kwargs.pop("align", ["CENTER", "CENTER"])
        if '"LEFT" "BOTTOM"' == align:
            pass
        elif '"LEFT" "CENTER"' == align:
            pass
        elif '"LEFT" "TOP"' == align:
            pass
        elif '"CENTER" "BOTTOM"' == align:
            pass
        elif '"CENTER" "CENTER"' == align:
            pass
        elif '"CENTER" "TOP"' == align:
            pass
        elif '"RIGHT" "BOTTOM"' == align:
            pass
        elif '"RIGHT" "CENTER"' == align:
            pass
        elif '"RIGHT" "TOP"' == align:
            pass
        else:
            return None
        self.__align = align
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        offset  = kwargs.pop("offset", [0, 0])
        self.__offset = offset
        offsetUnits  = kwargs.pop("offsetUnits", ["WORLD", "WORLD"])
        if '"WORLD" "WORLD"' == offsetUnits:
            pass
        elif '"WORLD" "FRACTION"' == offsetUnits:
            pass
        elif '"WORLD" "PIXEL"' == offsetUnits:
            pass
        elif '"FRACTION" "WORLD"' == offsetUnits:
            pass
        elif '"FRACTION" "FRACTION"' == offsetUnits:
            pass
        elif '"FRACTION" "PIXEL"' == offsetUnits:
            pass
        elif '"PIXEL" "WORLD"' == offsetUnits:
            pass
        elif '"PIXEL" "FRACTION"' == offsetUnits:
            pass
        elif '"PIXEL" "PIXEL"' == offsetUnits:
            pass
        else:
            return None
        self.__offsetUnits = offsetUnits
        scaleMode  = kwargs.pop("scaleMode", ["NONE", "NONE"])
        if '"NONE" "NONE"' == scaleMode:
            pass
        elif '"NONE" "FRACTION"' == scaleMode:
            pass
        elif '"NONE" "STRETCH"' == scaleMode:
            pass
        elif '"NONE" "PIXEL"' == scaleMode:
            pass
        elif '"FRACTION" "NONE"' == scaleMode:
            pass
        elif '"FRACTION" "FRACTION"' == scaleMode:
            pass
        elif '"FRACTION" "STRETCH"' == scaleMode:
            pass
        elif '"FRACTION" "PIXEL"' == scaleMode:
            pass
        elif '"STRETCH" "NONE"' == scaleMode:
            pass
        elif '"STRETCH" "FRACTION"' == scaleMode:
            pass
        elif '"STRETCH" "STRETCH"' == scaleMode:
            pass
        elif '"STRETCH" "PIXEL"' == scaleMode:
            pass
        elif '"PIXEL" "NONE"' == scaleMode:
            pass
        elif '"PIXEL" "FRACTION"' == scaleMode:
            pass
        elif '"PIXEL" "STRETCH"' == scaleMode:
            pass
        elif '"PIXEL" "PIXEL"' == scaleMode:
            pass
        else:
            return None
        self.__scaleMode = scaleMode
        size  = kwargs.pop("size", [1, 1])
        self.__size = size
        sizeUnits  = kwargs.pop("sizeUnits", ["WORLD", "WORLD"])
        if '"WORLD" "WORLD"' == sizeUnits:
            pass
        elif '"WORLD" "FRACTION"' == sizeUnits:
            pass
        elif '"WORLD" "PIXEL"' == sizeUnits:
            pass
        elif '"FRACTION" "WORLD"' == sizeUnits:
            pass
        elif '"FRACTION" "FRACTION"' == sizeUnits:
            pass
        elif '"FRACTION" "PIXEL"' == sizeUnits:
            pass
        elif '"PIXEL" "WORLD"' == sizeUnits:
            pass
        elif '"PIXEL" "FRACTION"' == sizeUnits:
            pass
        elif '"PIXEL" "PIXEL"' == sizeUnits:
            pass
        else:
            return None
        self.__sizeUnits = sizeUnits
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def align(self):
        return self.__align
    @align.setter
    def align(self, value = ["CENTER", "CENTER"]):
        if '"LEFT" "BOTTOM"' == value:
            pass
        elif '"LEFT" "CENTER"' == value:
            pass
        elif '"LEFT" "TOP"' == value:
            pass
        elif '"CENTER" "BOTTOM"' == value:
            pass
        elif '"CENTER" "CENTER"' == value:
            pass
        elif '"CENTER" "TOP"' == value:
            pass
        elif '"RIGHT" "BOTTOM"' == value:
            pass
        elif '"RIGHT" "CENTER"' == value:
            pass
        elif '"RIGHT" "TOP"' == value:
            pass
        else:
            return None
        self.__align = [value]
    def setAlign(self, align = ["CENTER", "CENTER"]):
        if '"LEFT" "BOTTOM"' == align:
            pass
        elif '"LEFT" "CENTER"' == align:
            pass
        elif '"LEFT" "TOP"' == align:
            pass
        elif '"CENTER" "BOTTOM"' == align:
            pass
        elif '"CENTER" "CENTER"' == align:
            pass
        elif '"CENTER" "TOP"' == align:
            pass
        elif '"RIGHT" "BOTTOM"' == align:
            pass
        elif '"RIGHT" "CENTER"' == align:
            pass
        elif '"RIGHT" "TOP"' == align:
            pass
        else:
            return None
        self.__align = [align]
        return self
    def addAlign(self, align = ["CENTER", "CENTER"]):
        if '"LEFT" "BOTTOM"' == align:
            pass
        elif '"LEFT" "CENTER"' == align:
            pass
        elif '"LEFT" "TOP"' == align:
            pass
        elif '"CENTER" "BOTTOM"' == align:
            pass
        elif '"CENTER" "CENTER"' == align:
            pass
        elif '"CENTER" "TOP"' == align:
            pass
        elif '"RIGHT" "BOTTOM"' == align:
            pass
        elif '"RIGHT" "CENTER"' == align:
            pass
        elif '"RIGHT" "TOP"' == align:
            pass
        else:
            return None
        if self.__align == None:            self.__align =  []
        self.__align +=  [align]
        return self
    def removeAlign(self, align):
        self.__align = [x for x in self.__align if x not in align]
        return self.__align
    def getAlign(self, align = ["CENTER", "CENTER"]):
        return self.__align
    def align_changed(self, align = ["CENTER", "CENTER"]):
        return self.__align
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def offset(self):
        return self.__offset
    @offset.setter
    def offset(self, value = [0, 0]):
        self.__offset = [value]
    def setOffset(self, offset = [0, 0]):
        self.__offset = [offset]
        return self
    def addOffset(self, offset = [0, 0]):
        if self.__offset == None:            self.__offset =  []
        self.__offset +=  [offset]
        return self
    def removeOffset(self, offset):
        self.__offset = [x for x in self.__offset if x not in offset]
        return self.__offset
    def getOffset(self, offset = [0, 0]):
        return self.__offset
    def offset_changed(self, offset = [0, 0]):
        return self.__offset
    @property
    def offsetUnits(self):
        return self.__offsetUnits
    @offsetUnits.setter
    def offsetUnits(self, value = ["WORLD", "WORLD"]):
        if '"WORLD" "WORLD"' == value:
            pass
        elif '"WORLD" "FRACTION"' == value:
            pass
        elif '"WORLD" "PIXEL"' == value:
            pass
        elif '"FRACTION" "WORLD"' == value:
            pass
        elif '"FRACTION" "FRACTION"' == value:
            pass
        elif '"FRACTION" "PIXEL"' == value:
            pass
        elif '"PIXEL" "WORLD"' == value:
            pass
        elif '"PIXEL" "FRACTION"' == value:
            pass
        elif '"PIXEL" "PIXEL"' == value:
            pass
        else:
            return None
        self.__offsetUnits = [value]
    def setOffsetUnits(self, offsetUnits = ["WORLD", "WORLD"]):
        if '"WORLD" "WORLD"' == offsetUnits:
            pass
        elif '"WORLD" "FRACTION"' == offsetUnits:
            pass
        elif '"WORLD" "PIXEL"' == offsetUnits:
            pass
        elif '"FRACTION" "WORLD"' == offsetUnits:
            pass
        elif '"FRACTION" "FRACTION"' == offsetUnits:
            pass
        elif '"FRACTION" "PIXEL"' == offsetUnits:
            pass
        elif '"PIXEL" "WORLD"' == offsetUnits:
            pass
        elif '"PIXEL" "FRACTION"' == offsetUnits:
            pass
        elif '"PIXEL" "PIXEL"' == offsetUnits:
            pass
        else:
            return None
        self.__offsetUnits = [offsetUnits]
        return self
    def addOffsetUnits(self, offsetUnits = ["WORLD", "WORLD"]):
        if '"WORLD" "WORLD"' == offsetUnits:
            pass
        elif '"WORLD" "FRACTION"' == offsetUnits:
            pass
        elif '"WORLD" "PIXEL"' == offsetUnits:
            pass
        elif '"FRACTION" "WORLD"' == offsetUnits:
            pass
        elif '"FRACTION" "FRACTION"' == offsetUnits:
            pass
        elif '"FRACTION" "PIXEL"' == offsetUnits:
            pass
        elif '"PIXEL" "WORLD"' == offsetUnits:
            pass
        elif '"PIXEL" "FRACTION"' == offsetUnits:
            pass
        elif '"PIXEL" "PIXEL"' == offsetUnits:
            pass
        else:
            return None
        if self.__offsetUnits == None:            self.__offsetUnits =  []
        self.__offsetUnits +=  [offsetUnits]
        return self
    def removeOffsetUnits(self, offsetUnits):
        self.__offsetUnits = [x for x in self.__offsetUnits if x not in offsetUnits]
        return self.__offsetUnits
    def getOffsetUnits(self, offsetUnits = ["WORLD", "WORLD"]):
        return self.__offsetUnits
    def offsetUnits_changed(self, offsetUnits = ["WORLD", "WORLD"]):
        return self.__offsetUnits
    @property
    def scaleMode(self):
        return self.__scaleMode
    @scaleMode.setter
    def scaleMode(self, value = ["NONE", "NONE"]):
        if '"NONE" "NONE"' == value:
            pass
        elif '"NONE" "FRACTION"' == value:
            pass
        elif '"NONE" "STRETCH"' == value:
            pass
        elif '"NONE" "PIXEL"' == value:
            pass
        elif '"FRACTION" "NONE"' == value:
            pass
        elif '"FRACTION" "FRACTION"' == value:
            pass
        elif '"FRACTION" "STRETCH"' == value:
            pass
        elif '"FRACTION" "PIXEL"' == value:
            pass
        elif '"STRETCH" "NONE"' == value:
            pass
        elif '"STRETCH" "FRACTION"' == value:
            pass
        elif '"STRETCH" "STRETCH"' == value:
            pass
        elif '"STRETCH" "PIXEL"' == value:
            pass
        elif '"PIXEL" "NONE"' == value:
            pass
        elif '"PIXEL" "FRACTION"' == value:
            pass
        elif '"PIXEL" "STRETCH"' == value:
            pass
        elif '"PIXEL" "PIXEL"' == value:
            pass
        else:
            return None
        self.__scaleMode = [value]
    def setScaleMode(self, scaleMode = ["NONE", "NONE"]):
        if '"NONE" "NONE"' == scaleMode:
            pass
        elif '"NONE" "FRACTION"' == scaleMode:
            pass
        elif '"NONE" "STRETCH"' == scaleMode:
            pass
        elif '"NONE" "PIXEL"' == scaleMode:
            pass
        elif '"FRACTION" "NONE"' == scaleMode:
            pass
        elif '"FRACTION" "FRACTION"' == scaleMode:
            pass
        elif '"FRACTION" "STRETCH"' == scaleMode:
            pass
        elif '"FRACTION" "PIXEL"' == scaleMode:
            pass
        elif '"STRETCH" "NONE"' == scaleMode:
            pass
        elif '"STRETCH" "FRACTION"' == scaleMode:
            pass
        elif '"STRETCH" "STRETCH"' == scaleMode:
            pass
        elif '"STRETCH" "PIXEL"' == scaleMode:
            pass
        elif '"PIXEL" "NONE"' == scaleMode:
            pass
        elif '"PIXEL" "FRACTION"' == scaleMode:
            pass
        elif '"PIXEL" "STRETCH"' == scaleMode:
            pass
        elif '"PIXEL" "PIXEL"' == scaleMode:
            pass
        else:
            return None
        self.__scaleMode = [scaleMode]
        return self
    def addScaleMode(self, scaleMode = ["NONE", "NONE"]):
        if '"NONE" "NONE"' == scaleMode:
            pass
        elif '"NONE" "FRACTION"' == scaleMode:
            pass
        elif '"NONE" "STRETCH"' == scaleMode:
            pass
        elif '"NONE" "PIXEL"' == scaleMode:
            pass
        elif '"FRACTION" "NONE"' == scaleMode:
            pass
        elif '"FRACTION" "FRACTION"' == scaleMode:
            pass
        elif '"FRACTION" "STRETCH"' == scaleMode:
            pass
        elif '"FRACTION" "PIXEL"' == scaleMode:
            pass
        elif '"STRETCH" "NONE"' == scaleMode:
            pass
        elif '"STRETCH" "FRACTION"' == scaleMode:
            pass
        elif '"STRETCH" "STRETCH"' == scaleMode:
            pass
        elif '"STRETCH" "PIXEL"' == scaleMode:
            pass
        elif '"PIXEL" "NONE"' == scaleMode:
            pass
        elif '"PIXEL" "FRACTION"' == scaleMode:
            pass
        elif '"PIXEL" "STRETCH"' == scaleMode:
            pass
        elif '"PIXEL" "PIXEL"' == scaleMode:
            pass
        else:
            return None
        if self.__scaleMode == None:            self.__scaleMode =  []
        self.__scaleMode +=  [scaleMode]
        return self
    def removeScaleMode(self, scaleMode):
        self.__scaleMode = [x for x in self.__scaleMode if x not in scaleMode]
        return self.__scaleMode
    def getScaleMode(self, scaleMode = ["NONE", "NONE"]):
        return self.__scaleMode
    def scaleMode_changed(self, scaleMode = ["NONE", "NONE"]):
        return self.__scaleMode
    @property
    def sizeUnits(self):
        return self.__sizeUnits
    @sizeUnits.setter
    def sizeUnits(self, value = ["WORLD", "WORLD"]):
        if '"WORLD" "WORLD"' == value:
            pass
        elif '"WORLD" "FRACTION"' == value:
            pass
        elif '"WORLD" "PIXEL"' == value:
            pass
        elif '"FRACTION" "WORLD"' == value:
            pass
        elif '"FRACTION" "FRACTION"' == value:
            pass
        elif '"FRACTION" "PIXEL"' == value:
            pass
        elif '"PIXEL" "WORLD"' == value:
            pass
        elif '"PIXEL" "FRACTION"' == value:
            pass
        elif '"PIXEL" "PIXEL"' == value:
            pass
        else:
            return None
        self.__sizeUnits = [value]
    def setSizeUnits(self, sizeUnits = ["WORLD", "WORLD"]):
        if '"WORLD" "WORLD"' == sizeUnits:
            pass
        elif '"WORLD" "FRACTION"' == sizeUnits:
            pass
        elif '"WORLD" "PIXEL"' == sizeUnits:
            pass
        elif '"FRACTION" "WORLD"' == sizeUnits:
            pass
        elif '"FRACTION" "FRACTION"' == sizeUnits:
            pass
        elif '"FRACTION" "PIXEL"' == sizeUnits:
            pass
        elif '"PIXEL" "WORLD"' == sizeUnits:
            pass
        elif '"PIXEL" "FRACTION"' == sizeUnits:
            pass
        elif '"PIXEL" "PIXEL"' == sizeUnits:
            pass
        else:
            return None
        self.__sizeUnits = [sizeUnits]
        return self
    def addSizeUnits(self, sizeUnits = ["WORLD", "WORLD"]):
        if '"WORLD" "WORLD"' == sizeUnits:
            pass
        elif '"WORLD" "FRACTION"' == sizeUnits:
            pass
        elif '"WORLD" "PIXEL"' == sizeUnits:
            pass
        elif '"FRACTION" "WORLD"' == sizeUnits:
            pass
        elif '"FRACTION" "FRACTION"' == sizeUnits:
            pass
        elif '"FRACTION" "PIXEL"' == sizeUnits:
            pass
        elif '"PIXEL" "WORLD"' == sizeUnits:
            pass
        elif '"PIXEL" "FRACTION"' == sizeUnits:
            pass
        elif '"PIXEL" "PIXEL"' == sizeUnits:
            pass
        else:
            return None
        if self.__sizeUnits == None:            self.__sizeUnits =  []
        self.__sizeUnits +=  [sizeUnits]
        return self
    def removeSizeUnits(self, sizeUnits):
        self.__sizeUnits = [x for x in self.__sizeUnits if x not in sizeUnits]
        return self.__sizeUnits
    def getSizeUnits(self, sizeUnits = ["WORLD", "WORLD"]):
        return self.__sizeUnits
    def sizeUnits_changed(self, sizeUnits = ["WORLD", "WORLD"]):
        return self.__sizeUnits
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Layout'
        if self.__align is not None:
            if isinstance(self.__align, six.string_types):
                str += ' align="'+self.__align+'"'
            else:
                str += ' align="'+self.__align[0]+'"'
        if self.__offset is not None:
            if isinstance(self.__offset, six.string_types):
                str += ' offset="'+self.__offset+'"'
            else:
                str += ' offset="'+self.__offset[0]+'"'
        if self.__offsetUnits is not None:
            if isinstance(self.__offsetUnits, six.string_types):
                str += ' offsetUnits="'+self.__offsetUnits+'"'
            else:
                str += ' offsetUnits="'+self.__offsetUnits[0]+'"'
        if self.__scaleMode is not None:
            if isinstance(self.__scaleMode, six.string_types):
                str += ' scaleMode="'+self.__scaleMode+'"'
            else:
                str += ' scaleMode="'+self.__scaleMode[0]+'"'
        if self.__size is not None:
            if isinstance(self.__size, six.string_types):
                str += ' size="'+self.__size+'"'
            else:
                str += ' size="'+self.__size[0]+'"'
        if self.__sizeUnits is not None:
            if isinstance(self.__sizeUnits, six.string_types):
                str += ' sizeUnits="'+self.__sizeUnits+'"'
            else:
                str += ' sizeUnits="'+self.__sizeUnits[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</Layout>'
        return str


class LayoutGroup(X3DGroupingNode, X3DNode):
    def __init__(self, **kwargs):
        super(LayoutGroup, self).__init__(**kwargs)
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        children  = kwargs.pop("children", None)
        self.__children = children
        layout  = kwargs.pop("layout", None)
        self.__layout = layout
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        viewport  = kwargs.pop("viewport", None)
        self.__viewport = viewport
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    def addChildren(self, Children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [Children]
        return self
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    @property
    def layout(self):
        return self.__layout
    @layout.setter
    def layout(self, value = None):
        self.__layout = [value]
    def setLayout(self, layout = None):
        self.__layout = [layout]
        return self
    def addLayout(self, layout = None):
        if self.__layout == None:            self.__layout =  []
        self.__layout +=  [layout]
        return self
    def removeLayout(self, layout):
        self.__layout = [x for x in self.__layout if x not in layout]
        return self.__layout
    def getLayout(self, layout = None):
        return self.__layout
    def layout_changed(self, layout = None):
        return self.__layout
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    @property
    def viewport(self):
        return self.__viewport
    @viewport.setter
    def viewport(self, value = None):
        self.__viewport = [value]
    def setViewport(self, viewport = None):
        self.__viewport = [viewport]
        return self
    def addViewport(self, viewport = None):
        if self.__viewport == None:            self.__viewport =  []
        self.__viewport +=  [viewport]
        return self
    def removeViewport(self, viewport):
        self.__viewport = [x for x in self.__viewport if x not in viewport]
        return self.__viewport
    def getViewport(self, viewport = None):
        return self.__viewport
    def viewport_changed(self, viewport = None):
        return self.__viewport
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<LayoutGroup'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '<layout'
        if self.__layout is not None:
           for s in self.__layout:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__layout is not None:
           for s in self.__layout:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</layout>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '<viewport'
        if self.__viewport is not None:
           for s in self.__viewport:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__viewport is not None:
           for s in self.__viewport:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</viewport>'
        str += '</LayoutGroup>'
        return str


class LayoutLayer(X3DLayerNode):
    def __init__(self, **kwargs):
        super(LayoutLayer, self).__init__(**kwargs)
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        children  = kwargs.pop("children", None)
        self.__children = children
        Pickable  = kwargs.pop("Pickable", True)
        self.__Pickable = Pickable
        layout  = kwargs.pop("layout", None)
        self.__layout = layout
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        viewport  = kwargs.pop("viewport", None)
        self.__viewport = viewport
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    def addChildren(self, Children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [Children]
        return self
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    @property
    def Pickable(self):
        return self.__Pickable
    @Pickable.setter
    def Pickable(self, value = True):
        self.__Pickable = [value]
    def setIsPickable(self, Pickable = True):
        self.__Pickable = [Pickable]
        return self
    def addIsPickable(self, Pickable = True):
        if self.__Pickable == None:            self.__Pickable =  []
        self.__Pickable +=  [Pickable]
        return self
    def isPickable(self, Pickable = True):
        return self.__Pickable
    @property
    def layout(self):
        return self.__layout
    @layout.setter
    def layout(self, value = None):
        self.__layout = [value]
    def setLayout(self, layout = None):
        self.__layout = [layout]
        return self
    def addLayout(self, layout = None):
        if self.__layout == None:            self.__layout =  []
        self.__layout +=  [layout]
        return self
    def removeLayout(self, layout):
        self.__layout = [x for x in self.__layout if x not in layout]
        return self.__layout
    def getLayout(self, layout = None):
        return self.__layout
    def layout_changed(self, layout = None):
        return self.__layout
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    @property
    def viewport(self):
        return self.__viewport
    @viewport.setter
    def viewport(self, value = None):
        self.__viewport = [value]
    def setViewport(self, viewport = None):
        self.__viewport = [viewport]
        return self
    def addViewport(self, viewport = None):
        if self.__viewport == None:            self.__viewport =  []
        self.__viewport +=  [viewport]
        return self
    def removeViewport(self, viewport):
        self.__viewport = [x for x in self.__viewport if x not in viewport]
        return self.__viewport
    def getViewport(self, viewport = None):
        return self.__viewport
    def viewport_changed(self, viewport = None):
        return self.__viewport
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<LayoutLayer'
        if self.__Pickable is not None:
            if isinstance(self.__Pickable, six.string_types):
                str += ' Pickable="'+self.__Pickable+'"'
            else:
                str += ' Pickable="'+self.__Pickable[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '<layout'
        if self.__layout is not None:
           for s in self.__layout:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__layout is not None:
           for s in self.__layout:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</layout>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '<viewport'
        if self.__viewport is not None:
           for s in self.__viewport:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__viewport is not None:
           for s in self.__viewport:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</viewport>'
        str += '</LayoutLayer>'
        return str


class LinePickSensor(X3DPickSensorNode):
    def __init__(self, **kwargs):
        super(LinePickSensor, self).__init__(**kwargs)
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        intersectionType  = kwargs.pop("intersectionType", "BOUNDS")
        self.__intersectionType = intersectionType
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        matchCriterion  = kwargs.pop("matchCriterion", "MATCH_ANY")
        if 'MATCH_ANY' == matchCriterion:
            pass
        elif 'MATCH_EVERY' == matchCriterion:
            pass
        elif 'MATCH_ONLY_ONE' == matchCriterion:
            pass
        else:
            return None
        self.__matchCriterion = matchCriterion
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        objectType  = kwargs.pop("objectType", ["ALL"])
        self.__objectType = objectType
        pickedGeometry  = kwargs.pop("pickedGeometry", None)
        self.__pickedGeometry = pickedGeometry
        pickedNormal  = kwargs.pop("pickedNormal", None)
        self.__pickedNormal = pickedNormal
        pickedPoint  = kwargs.pop("pickedPoint", None)
        self.__pickedPoint = pickedPoint
        pickedTextureCoordinate  = kwargs.pop("pickedTextureCoordinate", None)
        self.__pickedTextureCoordinate = pickedTextureCoordinate
        pickingGeometry  = kwargs.pop("pickingGeometry", None)
        self.__pickingGeometry = pickingGeometry
        pickTarget  = kwargs.pop("pickTarget", None)
        self.__pickTarget = pickTarget
        sortOrder  = kwargs.pop("sortOrder", "CLOSEST")
        self.__sortOrder = sortOrder
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    def isActive(self, Active = None):
        return self.__Active
    @property
    def matchCriterion(self):
        return self.__matchCriterion
    @matchCriterion.setter
    def matchCriterion(self, value = "MATCH_ANY"):
        if 'MATCH_ANY' == value:
            pass
        elif 'MATCH_EVERY' == value:
            pass
        elif 'MATCH_ONLY_ONE' == value:
            pass
        else:
            return None
        self.__matchCriterion = [value]
    def setMatchCriterion(self, matchCriterion = "MATCH_ANY"):
        if 'MATCH_ANY' == matchCriterion:
            pass
        elif 'MATCH_EVERY' == matchCriterion:
            pass
        elif 'MATCH_ONLY_ONE' == matchCriterion:
            pass
        else:
            return None
        self.__matchCriterion = [matchCriterion]
        return self
    def addMatchCriterion(self, matchCriterion = "MATCH_ANY"):
        if 'MATCH_ANY' == matchCriterion:
            pass
        elif 'MATCH_EVERY' == matchCriterion:
            pass
        elif 'MATCH_ONLY_ONE' == matchCriterion:
            pass
        else:
            return None
        if self.__matchCriterion == None:            self.__matchCriterion =  []
        self.__matchCriterion +=  [matchCriterion]
        return self
    def removeMatchCriterion(self, matchCriterion):
        self.__matchCriterion = [x for x in self.__matchCriterion if x not in matchCriterion]
        return self.__matchCriterion
    def getMatchCriterion(self, matchCriterion = "MATCH_ANY"):
        return self.__matchCriterion
    def matchCriterion_changed(self, matchCriterion = "MATCH_ANY"):
        return self.__matchCriterion
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def objectType(self):
        return self.__objectType
    @objectType.setter
    def objectType(self, value = ["ALL"]):
        self.__objectType = [value]
    def setObjectType(self, objectType = ["ALL"]):
        self.__objectType = [objectType]
        return self
    def addObjectType(self, objectType = ["ALL"]):
        if self.__objectType == None:            self.__objectType =  []
        self.__objectType +=  [objectType]
        return self
    def removeObjectType(self, objectType):
        self.__objectType = [x for x in self.__objectType if x not in objectType]
        return self.__objectType
    def getObjectType(self, objectType = ["ALL"]):
        return self.__objectType
    def objectType_changed(self, objectType = ["ALL"]):
        return self.__objectType
    def removePickedGeometry(self, pickedGeometry):
        self.__pickedGeometry = [x for x in self.__pickedGeometry if x not in pickedGeometry]
        return self.__pickedGeometry
    def getPickedGeometry(self, pickedGeometry = None):
        return self.__pickedGeometry
    def pickedGeometry_changed(self, pickedGeometry = None):
        return self.__pickedGeometry
    def removePickedNormal(self, pickedNormal):
        self.__pickedNormal = [x for x in self.__pickedNormal if x not in pickedNormal]
        return self.__pickedNormal
    def getPickedNormal(self, pickedNormal = None):
        return self.__pickedNormal
    def pickedNormal_changed(self, pickedNormal = None):
        return self.__pickedNormal
    def removePickedPoint(self, pickedPoint):
        self.__pickedPoint = [x for x in self.__pickedPoint if x not in pickedPoint]
        return self.__pickedPoint
    def getPickedPoint(self, pickedPoint = None):
        return self.__pickedPoint
    def pickedPoint_changed(self, pickedPoint = None):
        return self.__pickedPoint
    def removePickedTextureCoordinate(self, pickedTextureCoordinate):
        self.__pickedTextureCoordinate = [x for x in self.__pickedTextureCoordinate if x not in pickedTextureCoordinate]
        return self.__pickedTextureCoordinate
    def getPickedTextureCoordinate(self, pickedTextureCoordinate = None):
        return self.__pickedTextureCoordinate
    def pickedTextureCoordinate_changed(self, pickedTextureCoordinate = None):
        return self.__pickedTextureCoordinate
    @property
    def pickingGeometry(self):
        return self.__pickingGeometry
    @pickingGeometry.setter
    def pickingGeometry(self, value = None):
        self.__pickingGeometry = [value]
    def setPickingGeometry(self, pickingGeometry = None):
        self.__pickingGeometry = [pickingGeometry]
        return self
    def addPickingGeometry(self, pickingGeometry = None):
        if self.__pickingGeometry == None:            self.__pickingGeometry =  []
        self.__pickingGeometry +=  [pickingGeometry]
        return self
    def removePickingGeometry(self, pickingGeometry):
        self.__pickingGeometry = [x for x in self.__pickingGeometry if x not in pickingGeometry]
        return self.__pickingGeometry
    def getPickingGeometry(self, pickingGeometry = None):
        return self.__pickingGeometry
    def pickingGeometry_changed(self, pickingGeometry = None):
        return self.__pickingGeometry
    @property
    def pickTarget(self):
        return self.__pickTarget
    @pickTarget.setter
    def pickTarget(self, value = None):
        self.__pickTarget = [value]
    def setPickTarget(self, pickTarget = None):
        self.__pickTarget = [pickTarget]
        return self
    def addPickTarget(self, pickTarget = None):
        if self.__pickTarget == None:            self.__pickTarget =  []
        self.__pickTarget +=  [pickTarget]
        return self
    def removePickTarget(self, pickTarget):
        self.__pickTarget = [x for x in self.__pickTarget if x not in pickTarget]
        return self.__pickTarget
    def getPickTarget(self, pickTarget = None):
        return self.__pickTarget
    def pickTarget_changed(self, pickTarget = None):
        return self.__pickTarget
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<LinePickSensor'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__intersectionType is not None:
            if isinstance(self.__intersectionType, six.string_types):
                str += ' intersectionType="'+self.__intersectionType+'"'
            else:
                str += ' intersectionType="'+self.__intersectionType[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__matchCriterion is not None:
            if isinstance(self.__matchCriterion, six.string_types):
                str += ' matchCriterion="'+self.__matchCriterion+'"'
            else:
                str += ' matchCriterion="'+self.__matchCriterion[0]+'"'
        if self.__objectType is not None:
            if isinstance(self.__objectType, six.string_types):
                str += ' objectType="'+self.__objectType+'"'
            else:
                str += ' objectType="'+self.__objectType[0]+'"'
        if self.__pickedNormal is not None:
            if isinstance(self.__pickedNormal, six.string_types):
                str += ' pickedNormal="'+self.__pickedNormal+'"'
            else:
                str += ' pickedNormal="'+self.__pickedNormal[0]+'"'
        if self.__pickedPoint is not None:
            if isinstance(self.__pickedPoint, six.string_types):
                str += ' pickedPoint="'+self.__pickedPoint+'"'
            else:
                str += ' pickedPoint="'+self.__pickedPoint[0]+'"'
        if self.__pickedTextureCoordinate is not None:
            if isinstance(self.__pickedTextureCoordinate, six.string_types):
                str += ' pickedTextureCoordinate="'+self.__pickedTextureCoordinate+'"'
            else:
                str += ' pickedTextureCoordinate="'+self.__pickedTextureCoordinate[0]+'"'
        if self.__sortOrder is not None:
            if isinstance(self.__sortOrder, six.string_types):
                str += ' sortOrder="'+self.__sortOrder+'"'
            else:
                str += ' sortOrder="'+self.__sortOrder[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<pickedGeometry'
        if self.__pickedGeometry is not None:
           for s in self.__pickedGeometry:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__pickedGeometry is not None:
           for s in self.__pickedGeometry:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</pickedGeometry>'
        str += '<pickingGeometry'
        if self.__pickingGeometry is not None:
           for s in self.__pickingGeometry:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__pickingGeometry is not None:
           for s in self.__pickingGeometry:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</pickingGeometry>'
        str += '<pickTarget'
        if self.__pickTarget is not None:
           for s in self.__pickTarget:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__pickTarget is not None:
           for s in self.__pickTarget:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</pickTarget>'
        str += '</LinePickSensor>'
        return str


class LineProperties(X3DAppearanceChildNode):
    def __init__(self, **kwargs):
        super(LineProperties, self).__init__(**kwargs)
        applied  = kwargs.pop("applied", True)
        self.__applied = applied
        linetype  = kwargs.pop("linetype", 1)
        if linetype == None or linetype  <  1:
            return None
        self.__linetype = linetype
        linewidthScaleFactor  = kwargs.pop("linewidthScaleFactor", 0)
        self.__linewidthScaleFactor = linewidthScaleFactor
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def applied(self):
        return self.__applied
    @applied.setter
    def applied(self, value = True):
        self.__applied = [value]
    def setApplied(self, applied = True):
        self.__applied = [applied]
        return self
    def addApplied(self, applied = True):
        if self.__applied == None:            self.__applied =  []
        self.__applied +=  [applied]
        return self
    def removeApplied(self, applied):
        self.__applied = [x for x in self.__applied if x not in applied]
        return self.__applied
    def isApplied(self, applied = True):
        return self.__applied
    @property
    def linetype(self):
        return self.__linetype
    @linetype.setter
    def linetype(self, value = 1):
        if value == None or value  <  1:
            return None
        self.__linetype = [value]
    def setLinetype(self, linetype = 1):
        if linetype == None or linetype  <  1:
            return None
        self.__linetype = [linetype]
        return self
    def addLinetype(self, linetype = 1):
        if linetype == None or linetype  <  1:
            return None
        if self.__linetype == None:            self.__linetype =  []
        self.__linetype +=  [linetype]
        return self
    def removeLinetype(self, linetype):
        self.__linetype = [x for x in self.__linetype if x not in linetype]
        return self.__linetype
    def getLinetype(self, linetype = 1):
        return self.__linetype
    def linetype_changed(self, linetype = 1):
        return self.__linetype
    @property
    def linewidthScaleFactor(self):
        return self.__linewidthScaleFactor
    @linewidthScaleFactor.setter
    def linewidthScaleFactor(self, value = 0):
        self.__linewidthScaleFactor = [value]
    def setLinewidthScaleFactor(self, linewidthScaleFactor = 0):
        self.__linewidthScaleFactor = [linewidthScaleFactor]
        return self
    def addLinewidthScaleFactor(self, linewidthScaleFactor = 0):
        if self.__linewidthScaleFactor == None:            self.__linewidthScaleFactor =  []
        self.__linewidthScaleFactor +=  [linewidthScaleFactor]
        return self
    def removeLinewidthScaleFactor(self, linewidthScaleFactor):
        self.__linewidthScaleFactor = [x for x in self.__linewidthScaleFactor if x not in linewidthScaleFactor]
        return self.__linewidthScaleFactor
    def getLinewidthScaleFactor(self, linewidthScaleFactor = 0):
        return self.__linewidthScaleFactor
    def linewidthScaleFactor_changed(self, linewidthScaleFactor = 0):
        return self.__linewidthScaleFactor
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<LineProperties'
        if self.__applied is not None:
            if isinstance(self.__applied, six.string_types):
                str += ' applied="'+self.__applied+'"'
            else:
                str += ' applied="'+self.__applied[0]+'"'
        if self.__linetype is not None:
            if isinstance(self.__linetype, six.string_types):
                str += ' linetype="'+self.__linetype+'"'
            else:
                str += ' linetype="'+self.__linetype[0]+'"'
        if self.__linewidthScaleFactor is not None:
            if isinstance(self.__linewidthScaleFactor, six.string_types):
                str += ' linewidthScaleFactor="'+self.__linewidthScaleFactor+'"'
            else:
                str += ' linewidthScaleFactor="'+self.__linewidthScaleFactor[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</LineProperties>'
        return str


class LineSet(X3DGeometryNode):
    def __init__(self, **kwargs):
        super(LineSet, self).__init__(**kwargs)
        attrib  = kwargs.pop("attrib", None)
        self.__attrib = attrib
        color  = kwargs.pop("color", None)
        self.__color = color
        coord  = kwargs.pop("coord", None)
        self.__coord = coord
        fogCoord  = kwargs.pop("fogCoord", None)
        self.__fogCoord = fogCoord
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        vertexCount  = kwargs.pop("vertexCount", None)
        if vertexCount == None or len(vertexCount) <= 0 or min(vertexCount)  <  2:
            return None
        self.__vertexCount = vertexCount
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def attrib(self):
        return self.__attrib
    @attrib.setter
    def attrib(self, value = None):
        self.__attrib = [value]
    def setAttrib(self, attrib = None):
        self.__attrib = [attrib]
        return self
    def addAttrib(self, attrib = None):
        if self.__attrib == None:            self.__attrib =  []
        self.__attrib +=  [attrib]
        return self
    def removeAttrib(self, attrib):
        self.__attrib = [x for x in self.__attrib if x not in attrib]
        return self.__attrib
    def getAttrib(self, attrib = None):
        return self.__attrib
    def attrib_changed(self, attrib = None):
        return self.__attrib
    @property
    def color(self):
        return self.__color
    @color.setter
    def color(self, value = None):
        self.__color = [value]
    def setColor(self, color = None):
        self.__color = [color]
        return self
    def addColor(self, color = None):
        if self.__color == None:            self.__color =  []
        self.__color +=  [color]
        return self
    def removeColor(self, color):
        self.__color = [x for x in self.__color if x not in color]
        return self.__color
    def getColor(self, color = None):
        return self.__color
    def color_changed(self, color = None):
        return self.__color
    @property
    def coord(self):
        return self.__coord
    @coord.setter
    def coord(self, value = None):
        self.__coord = [value]
    def setCoord(self, coord = None):
        self.__coord = [coord]
        return self
    def addCoord(self, coord = None):
        if self.__coord == None:            self.__coord =  []
        self.__coord +=  [coord]
        return self
    def removeCoord(self, coord):
        self.__coord = [x for x in self.__coord if x not in coord]
        return self.__coord
    def getCoord(self, coord = None):
        return self.__coord
    def coord_changed(self, coord = None):
        return self.__coord
    @property
    def fogCoord(self):
        return self.__fogCoord
    @fogCoord.setter
    def fogCoord(self, value = None):
        self.__fogCoord = [value]
    def setFogCoord(self, fogCoord = None):
        self.__fogCoord = [fogCoord]
        return self
    def addFogCoord(self, fogCoord = None):
        if self.__fogCoord == None:            self.__fogCoord =  []
        self.__fogCoord +=  [fogCoord]
        return self
    def removeFogCoord(self, fogCoord):
        self.__fogCoord = [x for x in self.__fogCoord if x not in fogCoord]
        return self.__fogCoord
    def getFogCoord(self, fogCoord = None):
        return self.__fogCoord
    def fogCoord_changed(self, fogCoord = None):
        return self.__fogCoord
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def vertexCount(self):
        return self.__vertexCount
    @vertexCount.setter
    def vertexCount(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  2:
            return None
        self.__vertexCount = [value]
    def setVertexCount(self, vertexCount = None):
        if vertexCount == None or len(vertexCount) <= 0 or min(vertexCount)  <  2:
            return None
        self.__vertexCount = [vertexCount]
        return self
    def addVertexCount(self, vertexCount = None):
        if vertexCount == None or len(vertexCount) <= 0 or min(vertexCount)  <  2:
            return None
        if self.__vertexCount == None:            self.__vertexCount =  []
        self.__vertexCount +=  [vertexCount]
        return self
    def removeVertexCount(self, vertexCount):
        self.__vertexCount = [x for x in self.__vertexCount if x not in vertexCount]
        return self.__vertexCount
    def getVertexCount(self, vertexCount = None):
        return self.__vertexCount
    def vertexCount_changed(self, vertexCount = None):
        return self.__vertexCount
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<LineSet'
        if self.__vertexCount is not None:
            if isinstance(self.__vertexCount, six.string_types):
                str += ' vertexCount="'+self.__vertexCount+'"'
            else:
                str += ' vertexCount="'+self.__vertexCount[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<attrib'
        if self.__attrib is not None:
           for s in self.__attrib:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__attrib is not None:
           for s in self.__attrib:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</attrib>'
        str += '<color'
        if self.__color is not None:
           for s in self.__color:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__color is not None:
           for s in self.__color:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</color>'
        str += '<coord'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</coord>'
        str += '<fogCoord'
        if self.__fogCoord is not None:
           for s in self.__fogCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__fogCoord is not None:
           for s in self.__fogCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</fogCoord>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</LineSet>'
        return str


class LoadSensor(X3DNetworkSensorNode):
    def __init__(self, **kwargs):
        super(LoadSensor, self).__init__(**kwargs)
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        Loaded  = kwargs.pop("Loaded", None)
        self.__Loaded = Loaded
        loadTime  = kwargs.pop("loadTime", None)
        self.__loadTime = loadTime
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        progress  = kwargs.pop("progress", None)
        self.__progress = progress
        timeOut  = kwargs.pop("timeOut", 0)
        if timeOut == None or timeOut  <  0:
            return None
        self.__timeOut = timeOut
        watchList  = kwargs.pop("watchList", None)
        self.__watchList = watchList
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    def isActive(self, Active = None):
        return self.__Active
    def isLoaded(self, Loaded = None):
        return self.__Loaded
    def removeLoadTime(self, loadTime):
        self.__loadTime = [x for x in self.__loadTime if x not in loadTime]
        return self.__loadTime
    def getLoadTime(self, loadTime = None):
        return self.__loadTime
    def loadTime_changed(self, loadTime = None):
        return self.__loadTime
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    def removeProgress(self, progress):
        self.__progress = [x for x in self.__progress if x not in progress]
        return self.__progress
    def getProgress(self, progress = None):
        return self.__progress
    def progress_changed(self, progress = None):
        return self.__progress
    @property
    def timeOut(self):
        return self.__timeOut
    @timeOut.setter
    def timeOut(self, value = 0):
        if value == None or value  <  0:
            return None
        self.__timeOut = [value]
    def setTimeOut(self, timeOut = 0):
        if timeOut == None or timeOut  <  0:
            return None
        self.__timeOut = [timeOut]
        return self
    def addTimeOut(self, timeOut = 0):
        if timeOut == None or timeOut  <  0:
            return None
        if self.__timeOut == None:            self.__timeOut =  []
        self.__timeOut +=  [timeOut]
        return self
    def removeTimeOut(self, timeOut):
        self.__timeOut = [x for x in self.__timeOut if x not in timeOut]
        return self.__timeOut
    def getTimeOut(self, timeOut = 0):
        return self.__timeOut
    def timeOut_changed(self, timeOut = 0):
        return self.__timeOut
    @property
    def watchList(self):
        return self.__watchList
    @watchList.setter
    def watchList(self, value = None):
        self.__watchList = [value]
    def setWatchList(self, watchList = None):
        self.__watchList = [watchList]
        return self
    def addWatchList(self, watchList = None):
        if self.__watchList == None:            self.__watchList =  []
        self.__watchList +=  [watchList]
        return self
    def removeWatchList(self, watchList):
        self.__watchList = [x for x in self.__watchList if x not in watchList]
        return self.__watchList
    def getWatchList(self, watchList = None):
        return self.__watchList
    def watchList_changed(self, watchList = None):
        return self.__watchList
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<LoadSensor'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__Loaded is not None:
            if isinstance(self.__Loaded, six.string_types):
                str += ' Loaded="'+self.__Loaded+'"'
            else:
                str += ' Loaded="'+self.__Loaded[0]+'"'
        if self.__loadTime is not None:
            if isinstance(self.__loadTime, six.string_types):
                str += ' loadTime="'+self.__loadTime+'"'
            else:
                str += ' loadTime="'+self.__loadTime[0]+'"'
        if self.__progress is not None:
            if isinstance(self.__progress, six.string_types):
                str += ' progress="'+self.__progress+'"'
            else:
                str += ' progress="'+self.__progress[0]+'"'
        if self.__timeOut is not None:
            if isinstance(self.__timeOut, six.string_types):
                str += ' timeOut="'+self.__timeOut+'"'
            else:
                str += ' timeOut="'+self.__timeOut[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<watchList'
        if self.__watchList is not None:
           for s in self.__watchList:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__watchList is not None:
           for s in self.__watchList:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</watchList>'
        str += '</LoadSensor>'
        return str


class LocalFog(X3DFogObject, X3DChildNode):
    def __init__(self, **kwargs):
        super(LocalFog, self).__init__(**kwargs)
        color  = kwargs.pop("color", [1, 1, 1])
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        self.__color = color
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        fogType  = kwargs.pop("fogType", "LINEAR")
        if 'LINEAR' == fogType:
            pass
        elif 'EXPONENTIAL' == fogType:
            pass
        else:
            return None
        self.__fogType = fogType
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        visibilityRange  = kwargs.pop("visibilityRange", 0)
        if visibilityRange == None or visibilityRange  <  0:
            return None
        self.__visibilityRange = visibilityRange
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def color(self):
        return self.__color
    @color.setter
    def color(self, value = [1, 1, 1]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__color = [value]
    def setColor(self, color = [1, 1, 1]):
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        self.__color = [color]
        return self
    def addColor(self, color = [1, 1, 1]):
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        if self.__color == None:            self.__color =  []
        self.__color +=  [color]
        return self
    def removeColor(self, color):
        self.__color = [x for x in self.__color if x not in color]
        return self.__color
    def getColor(self, color = [1, 1, 1]):
        return self.__color
    def color_changed(self, color = [1, 1, 1]):
        return self.__color
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def fogType(self):
        return self.__fogType
    @fogType.setter
    def fogType(self, value = "LINEAR"):
        if 'LINEAR' == value:
            pass
        elif 'EXPONENTIAL' == value:
            pass
        else:
            return None
        self.__fogType = [value]
    def setFogType(self, fogType = "LINEAR"):
        if 'LINEAR' == fogType:
            pass
        elif 'EXPONENTIAL' == fogType:
            pass
        else:
            return None
        self.__fogType = [fogType]
        return self
    def addFogType(self, fogType = "LINEAR"):
        if 'LINEAR' == fogType:
            pass
        elif 'EXPONENTIAL' == fogType:
            pass
        else:
            return None
        if self.__fogType == None:            self.__fogType =  []
        self.__fogType +=  [fogType]
        return self
    def removeFogType(self, fogType):
        self.__fogType = [x for x in self.__fogType if x not in fogType]
        return self.__fogType
    def getFogType(self, fogType = "LINEAR"):
        return self.__fogType
    def fogType_changed(self, fogType = "LINEAR"):
        return self.__fogType
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def visibilityRange(self):
        return self.__visibilityRange
    @visibilityRange.setter
    def visibilityRange(self, value = 0):
        if value == None or value  <  0:
            return None
        self.__visibilityRange = [value]
    def setVisibilityRange(self, visibilityRange = 0):
        if visibilityRange == None or visibilityRange  <  0:
            return None
        self.__visibilityRange = [visibilityRange]
        return self
    def addVisibilityRange(self, visibilityRange = 0):
        if visibilityRange == None or visibilityRange  <  0:
            return None
        if self.__visibilityRange == None:            self.__visibilityRange =  []
        self.__visibilityRange +=  [visibilityRange]
        return self
    def removeVisibilityRange(self, visibilityRange):
        self.__visibilityRange = [x for x in self.__visibilityRange if x not in visibilityRange]
        return self.__visibilityRange
    def getVisibilityRange(self, visibilityRange = 0):
        return self.__visibilityRange
    def visibilityRange_changed(self, visibilityRange = 0):
        return self.__visibilityRange
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<LocalFog'
        if self.__color is not None:
            if isinstance(self.__color, six.string_types):
                str += ' color="'+self.__color+'"'
            else:
                str += ' color="'+self.__color[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__fogType is not None:
            if isinstance(self.__fogType, six.string_types):
                str += ' fogType="'+self.__fogType+'"'
            else:
                str += ' fogType="'+self.__fogType[0]+'"'
        if self.__visibilityRange is not None:
            if isinstance(self.__visibilityRange, six.string_types):
                str += ' visibilityRange="'+self.__visibilityRange+'"'
            else:
                str += ' visibilityRange="'+self.__visibilityRange[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</LocalFog>'
        return str


class LOD(X3DGroupingNode):
    def __init__(self, **kwargs):
        super(LOD, self).__init__(**kwargs)
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        center  = kwargs.pop("center", [0, 0, 0])
        self.__center = center
        children  = kwargs.pop("children", None)
        self.__children = children
        forceTransitions  = kwargs.pop("forceTransitions", False)
        self.__forceTransitions = forceTransitions
        level_changed  = kwargs.pop("level_changed", None)
        if level_changed == None or level_changed  <  0:
            return None
        self.__level_changed = level_changed
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        range  = kwargs.pop("range", None)
        self.__range = range
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    def addChildren(self, Children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [Children]
        return self
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    def removelevel_changed(self, level_changed):
        self.__level_changed = [x for x in self.__level_changed if x not in level_changed]
        return self.__level_changed
    def getlevel_changed(self, level_changed = None):
        return self.__level_changed
    def level_changed_changed(self, level_changed = None):
        return self.__level_changed
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<LOD'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__center is not None:
            if isinstance(self.__center, six.string_types):
                str += ' center="'+self.__center+'"'
            else:
                str += ' center="'+self.__center[0]+'"'
        if self.__forceTransitions is not None:
            if isinstance(self.__forceTransitions, six.string_types):
                str += ' forceTransitions="'+self.__forceTransitions+'"'
            else:
                str += ' forceTransitions="'+self.__forceTransitions[0]+'"'
        if self.__level_changed is not None:
            if isinstance(self.__level_changed, six.string_types):
                str += ' level_changed="'+self.__level_changed+'"'
            else:
                str += ' level_changed="'+self.__level_changed[0]+'"'
        if self.__range is not None:
            if isinstance(self.__range, six.string_types):
                str += ' range="'+self.__range+'"'
            else:
                str += ' range="'+self.__range[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '</LOD>'
        return str


class Material(X3DMaterialNode):
    def __init__(self, **kwargs):
        super(Material, self).__init__(**kwargs)
        ambientIntensity  = kwargs.pop("ambientIntensity", 0.2)
        if ambientIntensity == None or ambientIntensity  <  0:
            return None
        if ambientIntensity == None or ambientIntensity  >  1:
            return None
        self.__ambientIntensity = ambientIntensity
        diffuseColor  = kwargs.pop("diffuseColor", [0.8, 0.8, 0.8])
        if diffuseColor == None or len(diffuseColor) <= 0 or min(diffuseColor)  <  0:
            return None
        if diffuseColor == None or len(diffuseColor) <= 0 or max(diffuseColor)  >  1:
            return None
        self.__diffuseColor = diffuseColor
        emissiveColor  = kwargs.pop("emissiveColor", [0, 0, 0])
        if emissiveColor == None or len(emissiveColor) <= 0 or min(emissiveColor)  <  0:
            return None
        if emissiveColor == None or len(emissiveColor) <= 0 or max(emissiveColor)  >  1:
            return None
        self.__emissiveColor = emissiveColor
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        shininess  = kwargs.pop("shininess", 0.2)
        if shininess == None or shininess  <  0:
            return None
        if shininess == None or shininess  >  1:
            return None
        self.__shininess = shininess
        specularColor  = kwargs.pop("specularColor", [0, 0, 0])
        if specularColor == None or len(specularColor) <= 0 or min(specularColor)  <  0:
            return None
        if specularColor == None or len(specularColor) <= 0 or max(specularColor)  >  1:
            return None
        self.__specularColor = specularColor
        transparency  = kwargs.pop("transparency", 0)
        if transparency == None or transparency  <  0:
            return None
        if transparency == None or transparency  >  1:
            return None
        self.__transparency = transparency
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def ambientIntensity(self):
        return self.__ambientIntensity
    @ambientIntensity.setter
    def ambientIntensity(self, value = 0.2):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__ambientIntensity = [value]
    def setAmbientIntensity(self, ambientIntensity = 0.2):
        if ambientIntensity == None or ambientIntensity  <  0:
            return None
        if ambientIntensity == None or ambientIntensity  >  1:
            return None
        self.__ambientIntensity = [ambientIntensity]
        return self
    def addAmbientIntensity(self, ambientIntensity = 0.2):
        if ambientIntensity == None or ambientIntensity  <  0:
            return None
        if ambientIntensity == None or ambientIntensity  >  1:
            return None
        if self.__ambientIntensity == None:            self.__ambientIntensity =  []
        self.__ambientIntensity +=  [ambientIntensity]
        return self
    def removeAmbientIntensity(self, ambientIntensity):
        self.__ambientIntensity = [x for x in self.__ambientIntensity if x not in ambientIntensity]
        return self.__ambientIntensity
    def getAmbientIntensity(self, ambientIntensity = 0.2):
        return self.__ambientIntensity
    def ambientIntensity_changed(self, ambientIntensity = 0.2):
        return self.__ambientIntensity
    @property
    def diffuseColor(self):
        return self.__diffuseColor
    @diffuseColor.setter
    def diffuseColor(self, value = [0.8, 0.8, 0.8]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__diffuseColor = [value]
    def setDiffuseColor(self, diffuseColor = [0.8, 0.8, 0.8]):
        if diffuseColor == None or len(diffuseColor) <= 0 or min(diffuseColor)  <  0:
            return None
        if diffuseColor == None or len(diffuseColor) <= 0 or max(diffuseColor)  >  1:
            return None
        self.__diffuseColor = [diffuseColor]
        return self
    def addDiffuseColor(self, diffuseColor = [0.8, 0.8, 0.8]):
        if diffuseColor == None or len(diffuseColor) <= 0 or min(diffuseColor)  <  0:
            return None
        if diffuseColor == None or len(diffuseColor) <= 0 or max(diffuseColor)  >  1:
            return None
        if self.__diffuseColor == None:            self.__diffuseColor =  []
        self.__diffuseColor +=  [diffuseColor]
        return self
    def removeDiffuseColor(self, diffuseColor):
        self.__diffuseColor = [x for x in self.__diffuseColor if x not in diffuseColor]
        return self.__diffuseColor
    def getDiffuseColor(self, diffuseColor = [0.8, 0.8, 0.8]):
        return self.__diffuseColor
    def diffuseColor_changed(self, diffuseColor = [0.8, 0.8, 0.8]):
        return self.__diffuseColor
    @property
    def emissiveColor(self):
        return self.__emissiveColor
    @emissiveColor.setter
    def emissiveColor(self, value = [0, 0, 0]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__emissiveColor = [value]
    def setEmissiveColor(self, emissiveColor = [0, 0, 0]):
        if emissiveColor == None or len(emissiveColor) <= 0 or min(emissiveColor)  <  0:
            return None
        if emissiveColor == None or len(emissiveColor) <= 0 or max(emissiveColor)  >  1:
            return None
        self.__emissiveColor = [emissiveColor]
        return self
    def addEmissiveColor(self, emissiveColor = [0, 0, 0]):
        if emissiveColor == None or len(emissiveColor) <= 0 or min(emissiveColor)  <  0:
            return None
        if emissiveColor == None or len(emissiveColor) <= 0 or max(emissiveColor)  >  1:
            return None
        if self.__emissiveColor == None:            self.__emissiveColor =  []
        self.__emissiveColor +=  [emissiveColor]
        return self
    def removeEmissiveColor(self, emissiveColor):
        self.__emissiveColor = [x for x in self.__emissiveColor if x not in emissiveColor]
        return self.__emissiveColor
    def getEmissiveColor(self, emissiveColor = [0, 0, 0]):
        return self.__emissiveColor
    def emissiveColor_changed(self, emissiveColor = [0, 0, 0]):
        return self.__emissiveColor
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def shininess(self):
        return self.__shininess
    @shininess.setter
    def shininess(self, value = 0.2):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__shininess = [value]
    def setShininess(self, shininess = 0.2):
        if shininess == None or shininess  <  0:
            return None
        if shininess == None or shininess  >  1:
            return None
        self.__shininess = [shininess]
        return self
    def addShininess(self, shininess = 0.2):
        if shininess == None or shininess  <  0:
            return None
        if shininess == None or shininess  >  1:
            return None
        if self.__shininess == None:            self.__shininess =  []
        self.__shininess +=  [shininess]
        return self
    def removeShininess(self, shininess):
        self.__shininess = [x for x in self.__shininess if x not in shininess]
        return self.__shininess
    def getShininess(self, shininess = 0.2):
        return self.__shininess
    def shininess_changed(self, shininess = 0.2):
        return self.__shininess
    @property
    def specularColor(self):
        return self.__specularColor
    @specularColor.setter
    def specularColor(self, value = [0, 0, 0]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__specularColor = [value]
    def setSpecularColor(self, specularColor = [0, 0, 0]):
        if specularColor == None or len(specularColor) <= 0 or min(specularColor)  <  0:
            return None
        if specularColor == None or len(specularColor) <= 0 or max(specularColor)  >  1:
            return None
        self.__specularColor = [specularColor]
        return self
    def addSpecularColor(self, specularColor = [0, 0, 0]):
        if specularColor == None or len(specularColor) <= 0 or min(specularColor)  <  0:
            return None
        if specularColor == None or len(specularColor) <= 0 or max(specularColor)  >  1:
            return None
        if self.__specularColor == None:            self.__specularColor =  []
        self.__specularColor +=  [specularColor]
        return self
    def removeSpecularColor(self, specularColor):
        self.__specularColor = [x for x in self.__specularColor if x not in specularColor]
        return self.__specularColor
    def getSpecularColor(self, specularColor = [0, 0, 0]):
        return self.__specularColor
    def specularColor_changed(self, specularColor = [0, 0, 0]):
        return self.__specularColor
    @property
    def transparency(self):
        return self.__transparency
    @transparency.setter
    def transparency(self, value = 0):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__transparency = [value]
    def setTransparency(self, transparency = 0):
        if transparency == None or transparency  <  0:
            return None
        if transparency == None or transparency  >  1:
            return None
        self.__transparency = [transparency]
        return self
    def addTransparency(self, transparency = 0):
        if transparency == None or transparency  <  0:
            return None
        if transparency == None or transparency  >  1:
            return None
        if self.__transparency == None:            self.__transparency =  []
        self.__transparency +=  [transparency]
        return self
    def removeTransparency(self, transparency):
        self.__transparency = [x for x in self.__transparency if x not in transparency]
        return self.__transparency
    def getTransparency(self, transparency = 0):
        return self.__transparency
    def transparency_changed(self, transparency = 0):
        return self.__transparency
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    @property
    def IS(self):
        return self.__IS
    @IS.setter
    def IS(self, value = None):
        self.__IS = [value]
    def setIS(self, IS = None):
        self.__IS = [IS]
        return self
    def addIS(self, IS = None):
        if self.__IS == None:            self.__IS =  []
        self.__IS +=  [IS]
        return self
    def removeIS(self, IS):
        self.__IS = [x for x in self.__IS if x not in IS]
        return self.__IS
    def getIS(self, IS = None):
        return self.__IS
    def IS_changed(self, IS = None):
        return self.__IS
    def toXML(self):
        str = ''
        str += '<Material'
        if self.__ambientIntensity is not None:
            if isinstance(self.__ambientIntensity, six.string_types):
                str += ' ambientIntensity="'+self.__ambientIntensity+'"'
            else:
                str += ' ambientIntensity="'+self.__ambientIntensity[0]+'"'
        if self.__diffuseColor is not None:
            if isinstance(self.__diffuseColor, six.string_types):
                str += ' diffuseColor="'+self.__diffuseColor+'"'
            else:
                str += ' diffuseColor="'+self.__diffuseColor[0]+'"'
        if self.__emissiveColor is not None:
            if isinstance(self.__emissiveColor, six.string_types):
                str += ' emissiveColor="'+self.__emissiveColor+'"'
            else:
                str += ' emissiveColor="'+self.__emissiveColor[0]+'"'
        if self.__shininess is not None:
            if isinstance(self.__shininess, six.string_types):
                str += ' shininess="'+self.__shininess+'"'
            else:
                str += ' shininess="'+self.__shininess[0]+'"'
        if self.__specularColor is not None:
            if isinstance(self.__specularColor, six.string_types):
                str += ' specularColor="'+self.__specularColor+'"'
            else:
                str += ' specularColor="'+self.__specularColor[0]+'"'
        if self.__transparency is not None:
            if isinstance(self.__transparency, six.string_types):
                str += ' transparency="'+self.__transparency+'"'
            else:
                str += ' transparency="'+self.__transparency[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</Material>'
        return str


class Matrix3VertexAttribute(X3DVertexAttributeNode):
    def __init__(self, **kwargs):
        super(Matrix3VertexAttribute, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        name  = kwargs.pop("name", None)
        self.__name = name
        value  = kwargs.pop("value", None)
        self.__value = value
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        self.__name = [value]
    def setName(self, name = None):
        self.__name = [name]
        return self
    def addName(self, name = None):
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def value(self):
        return self.__value
    @value.setter
    def value(self, value = None):
        self.__value = [value]
    def setValue(self, value = None):
        self.__value = [value]
        return self
    def addValue(self, value = None):
        if self.__value == None:            self.__value =  []
        self.__value +=  [value]
        return self
    def removeValue(self, value):
        self.__value = [x for x in self.__value if x not in value]
        return self.__value
    def getValue(self, value = None):
        return self.__value
    def value_changed(self, value = None):
        return self.__value
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Matrix3VertexAttribute'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        if self.__value is not None:
            if isinstance(self.__value, six.string_types):
                str += ' value="'+self.__value+'"'
            else:
                str += ' value="'+self.__value[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</Matrix3VertexAttribute>'
        return str


class Matrix4VertexAttribute(X3DVertexAttributeNode):
    def __init__(self, **kwargs):
        super(Matrix4VertexAttribute, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        name  = kwargs.pop("name", None)
        self.__name = name
        value  = kwargs.pop("value", None)
        self.__value = value
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        self.__name = [value]
    def setName(self, name = None):
        self.__name = [name]
        return self
    def addName(self, name = None):
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def value(self):
        return self.__value
    @value.setter
    def value(self, value = None):
        self.__value = [value]
    def setValue(self, value = None):
        self.__value = [value]
        return self
    def addValue(self, value = None):
        if self.__value == None:            self.__value =  []
        self.__value +=  [value]
        return self
    def removeValue(self, value):
        self.__value = [x for x in self.__value if x not in value]
        return self.__value
    def getValue(self, value = None):
        return self.__value
    def value_changed(self, value = None):
        return self.__value
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Matrix4VertexAttribute'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        if self.__value is not None:
            if isinstance(self.__value, six.string_types):
                str += ' value="'+self.__value+'"'
            else:
                str += ' value="'+self.__value[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</Matrix4VertexAttribute>'
        return str


class MetadataBoolean(X3DNode, X3DMetadataObject):
    def __init__(self, **kwargs):
        super(MetadataBoolean, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        name  = kwargs.pop("name", None)
        self.__name = name
        reference  = kwargs.pop("reference", None)
        self.__reference = reference
        value  = kwargs.pop("value", None)
        self.__value = value
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        self.__name = [value]
    def setName(self, name = None):
        self.__name = [name]
        return self
    def addName(self, name = None):
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def reference(self):
        return self.__reference
    @reference.setter
    def reference(self, value = None):
        self.__reference = [value]
    def setReference(self, reference = None):
        self.__reference = [reference]
        return self
    def addReference(self, reference = None):
        if self.__reference == None:            self.__reference =  []
        self.__reference +=  [reference]
        return self
    def removeReference(self, reference):
        self.__reference = [x for x in self.__reference if x not in reference]
        return self.__reference
    def getReference(self, reference = None):
        return self.__reference
    def reference_changed(self, reference = None):
        return self.__reference
    @property
    def value(self):
        return self.__value
    @value.setter
    def value(self, value = None):
        self.__value = [value]
    def setValue(self, value = None):
        self.__value = [value]
        return self
    def addValue(self, value = None):
        if self.__value == None:            self.__value =  []
        self.__value +=  [value]
        return self
    def removeValue(self, value):
        self.__value = [x for x in self.__value if x not in value]
        return self.__value
    def getValue(self, value = None):
        return self.__value
    def value_changed(self, value = None):
        return self.__value
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<MetadataBoolean'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        if self.__reference is not None:
            if isinstance(self.__reference, six.string_types):
                str += ' reference="'+self.__reference+'"'
            else:
                str += ' reference="'+self.__reference[0]+'"'
        if self.__value is not None:
            if isinstance(self.__value, six.string_types):
                str += ' value="'+self.__value+'"'
            else:
                str += ' value="'+self.__value[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</MetadataBoolean>'
        return str


class MetadataDouble(X3DNode, X3DMetadataObject):
    def __init__(self, **kwargs):
        super(MetadataDouble, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        name  = kwargs.pop("name", None)
        self.__name = name
        reference  = kwargs.pop("reference", None)
        self.__reference = reference
        value  = kwargs.pop("value", None)
        self.__value = value
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        self.__name = [value]
    def setName(self, name = None):
        self.__name = [name]
        return self
    def addName(self, name = None):
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def reference(self):
        return self.__reference
    @reference.setter
    def reference(self, value = None):
        self.__reference = [value]
    def setReference(self, reference = None):
        self.__reference = [reference]
        return self
    def addReference(self, reference = None):
        if self.__reference == None:            self.__reference =  []
        self.__reference +=  [reference]
        return self
    def removeReference(self, reference):
        self.__reference = [x for x in self.__reference if x not in reference]
        return self.__reference
    def getReference(self, reference = None):
        return self.__reference
    def reference_changed(self, reference = None):
        return self.__reference
    @property
    def value(self):
        return self.__value
    @value.setter
    def value(self, value = None):
        self.__value = [value]
    def setValue(self, value = None):
        self.__value = [value]
        return self
    def addValue(self, value = None):
        if self.__value == None:            self.__value =  []
        self.__value +=  [value]
        return self
    def removeValue(self, value):
        self.__value = [x for x in self.__value if x not in value]
        return self.__value
    def getValue(self, value = None):
        return self.__value
    def value_changed(self, value = None):
        return self.__value
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<MetadataDouble'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        if self.__reference is not None:
            if isinstance(self.__reference, six.string_types):
                str += ' reference="'+self.__reference+'"'
            else:
                str += ' reference="'+self.__reference[0]+'"'
        if self.__value is not None:
            if isinstance(self.__value, six.string_types):
                str += ' value="'+self.__value+'"'
            else:
                str += ' value="'+self.__value[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</MetadataDouble>'
        return str


class MetadataFloat(X3DNode, X3DMetadataObject):
    def __init__(self, **kwargs):
        super(MetadataFloat, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        name  = kwargs.pop("name", None)
        self.__name = name
        reference  = kwargs.pop("reference", None)
        self.__reference = reference
        value  = kwargs.pop("value", None)
        self.__value = value
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        self.__name = [value]
    def setName(self, name = None):
        self.__name = [name]
        return self
    def addName(self, name = None):
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def reference(self):
        return self.__reference
    @reference.setter
    def reference(self, value = None):
        self.__reference = [value]
    def setReference(self, reference = None):
        self.__reference = [reference]
        return self
    def addReference(self, reference = None):
        if self.__reference == None:            self.__reference =  []
        self.__reference +=  [reference]
        return self
    def removeReference(self, reference):
        self.__reference = [x for x in self.__reference if x not in reference]
        return self.__reference
    def getReference(self, reference = None):
        return self.__reference
    def reference_changed(self, reference = None):
        return self.__reference
    @property
    def value(self):
        return self.__value
    @value.setter
    def value(self, value = None):
        self.__value = [value]
    def setValue(self, value = None):
        self.__value = [value]
        return self
    def addValue(self, value = None):
        if self.__value == None:            self.__value =  []
        self.__value +=  [value]
        return self
    def removeValue(self, value):
        self.__value = [x for x in self.__value if x not in value]
        return self.__value
    def getValue(self, value = None):
        return self.__value
    def value_changed(self, value = None):
        return self.__value
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<MetadataFloat'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        if self.__reference is not None:
            if isinstance(self.__reference, six.string_types):
                str += ' reference="'+self.__reference+'"'
            else:
                str += ' reference="'+self.__reference[0]+'"'
        if self.__value is not None:
            if isinstance(self.__value, six.string_types):
                str += ' value="'+self.__value+'"'
            else:
                str += ' value="'+self.__value[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</MetadataFloat>'
        return str


class MetadataInteger(X3DNode, X3DMetadataObject):
    def __init__(self, **kwargs):
        super(MetadataInteger, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        name  = kwargs.pop("name", None)
        self.__name = name
        reference  = kwargs.pop("reference", None)
        self.__reference = reference
        value  = kwargs.pop("value", None)
        self.__value = value
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        self.__name = [value]
    def setName(self, name = None):
        self.__name = [name]
        return self
    def addName(self, name = None):
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def reference(self):
        return self.__reference
    @reference.setter
    def reference(self, value = None):
        self.__reference = [value]
    def setReference(self, reference = None):
        self.__reference = [reference]
        return self
    def addReference(self, reference = None):
        if self.__reference == None:            self.__reference =  []
        self.__reference +=  [reference]
        return self
    def removeReference(self, reference):
        self.__reference = [x for x in self.__reference if x not in reference]
        return self.__reference
    def getReference(self, reference = None):
        return self.__reference
    def reference_changed(self, reference = None):
        return self.__reference
    @property
    def value(self):
        return self.__value
    @value.setter
    def value(self, value = None):
        self.__value = [value]
    def setValue(self, value = None):
        self.__value = [value]
        return self
    def addValue(self, value = None):
        if self.__value == None:            self.__value =  []
        self.__value +=  [value]
        return self
    def removeValue(self, value):
        self.__value = [x for x in self.__value if x not in value]
        return self.__value
    def getValue(self, value = None):
        return self.__value
    def value_changed(self, value = None):
        return self.__value
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<MetadataInteger'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        if self.__reference is not None:
            if isinstance(self.__reference, six.string_types):
                str += ' reference="'+self.__reference+'"'
            else:
                str += ' reference="'+self.__reference[0]+'"'
        if self.__value is not None:
            if isinstance(self.__value, six.string_types):
                str += ' value="'+self.__value+'"'
            else:
                str += ' value="'+self.__value[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</MetadataInteger>'
        return str


class MetadataSet(X3DMetadataObject, X3DNode):
    def __init__(self, **kwargs):
        super(MetadataSet, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        name  = kwargs.pop("name", None)
        self.__name = name
        reference  = kwargs.pop("reference", None)
        self.__reference = reference
        value  = kwargs.pop("value", None)
        self.__value = value
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        self.__name = [value]
    def setName(self, name = None):
        self.__name = [name]
        return self
    def addName(self, name = None):
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def reference(self):
        return self.__reference
    @reference.setter
    def reference(self, value = None):
        self.__reference = [value]
    def setReference(self, reference = None):
        self.__reference = [reference]
        return self
    def addReference(self, reference = None):
        if self.__reference == None:            self.__reference =  []
        self.__reference +=  [reference]
        return self
    def removeReference(self, reference):
        self.__reference = [x for x in self.__reference if x not in reference]
        return self.__reference
    def getReference(self, reference = None):
        return self.__reference
    def reference_changed(self, reference = None):
        return self.__reference
    @property
    def value(self):
        return self.__value
    @value.setter
    def value(self, value = None):
        self.__value = [value]
    def setValue(self, value = None):
        self.__value = [value]
        return self
    def addValue(self, value = None):
        if self.__value == None:            self.__value =  []
        self.__value +=  [value]
        return self
    def removeValue(self, value):
        self.__value = [x for x in self.__value if x not in value]
        return self.__value
    def getValue(self, value = None):
        return self.__value
    def value_changed(self, value = None):
        return self.__value
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<MetadataSet'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        if self.__reference is not None:
            if isinstance(self.__reference, six.string_types):
                str += ' reference="'+self.__reference+'"'
            else:
                str += ' reference="'+self.__reference[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<value'
        if self.__value is not None:
           for s in self.__value:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__value is not None:
           for s in self.__value:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</value>'
        str += '</MetadataSet>'
        return str


class MetadataString(X3DNode, X3DMetadataObject):
    def __init__(self, **kwargs):
        super(MetadataString, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        name  = kwargs.pop("name", None)
        self.__name = name
        reference  = kwargs.pop("reference", None)
        self.__reference = reference
        value  = kwargs.pop("value", None)
        self.__value = value
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        self.__name = [value]
    def setName(self, name = None):
        self.__name = [name]
        return self
    def addName(self, name = None):
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def reference(self):
        return self.__reference
    @reference.setter
    def reference(self, value = None):
        self.__reference = [value]
    def setReference(self, reference = None):
        self.__reference = [reference]
        return self
    def addReference(self, reference = None):
        if self.__reference == None:            self.__reference =  []
        self.__reference +=  [reference]
        return self
    def removeReference(self, reference):
        self.__reference = [x for x in self.__reference if x not in reference]
        return self.__reference
    def getReference(self, reference = None):
        return self.__reference
    def reference_changed(self, reference = None):
        return self.__reference
    @property
    def value(self):
        return self.__value
    @value.setter
    def value(self, value = None):
        self.__value = [value]
    def setValue(self, value = None):
        self.__value = [value]
        return self
    def addValue(self, value = None):
        if self.__value == None:            self.__value =  []
        self.__value +=  [value]
        return self
    def removeValue(self, value):
        self.__value = [x for x in self.__value if x not in value]
        return self.__value
    def getValue(self, value = None):
        return self.__value
    def value_changed(self, value = None):
        return self.__value
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<MetadataString'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        if self.__reference is not None:
            if isinstance(self.__reference, six.string_types):
                str += ' reference="'+self.__reference+'"'
            else:
                str += ' reference="'+self.__reference[0]+'"'
        if self.__value is not None:
            if isinstance(self.__value, six.string_types):
                str += ' value="'+self.__value+'"'
            else:
                str += ' value="'+self.__value[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</MetadataString>'
        return str


class MotorJoint(X3DRigidJointNode):
    def __init__(self, **kwargs):
        super(MotorJoint, self).__init__(**kwargs)
        autoCalc  = kwargs.pop("autoCalc", False)
        self.__autoCalc = autoCalc
        axis1Angle  = kwargs.pop("axis1Angle", 0)
        self.__axis1Angle = axis1Angle
        axis1Torque  = kwargs.pop("axis1Torque", 0)
        self.__axis1Torque = axis1Torque
        axis2Angle  = kwargs.pop("axis2Angle", 0)
        self.__axis2Angle = axis2Angle
        axis2Torque  = kwargs.pop("axis2Torque", 0)
        self.__axis2Torque = axis2Torque
        axis3Angle  = kwargs.pop("axis3Angle", 0)
        self.__axis3Angle = axis3Angle
        axis3Torque  = kwargs.pop("axis3Torque", 0)
        self.__axis3Torque = axis3Torque
        body1  = kwargs.pop("body1", None)
        self.__body1 = body1
        body2  = kwargs.pop("body2", None)
        self.__body2 = body2
        enabledAxes  = kwargs.pop("enabledAxes", 1)
        if enabledAxes == None or enabledAxes  <  0:
            return None
        if enabledAxes == None or enabledAxes  >  3:
            return None
        self.__enabledAxes = enabledAxes
        forceOutput  = kwargs.pop("forceOutput", ["NONE"])
        self.__forceOutput = forceOutput
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        motor1Angle  = kwargs.pop("motor1Angle", None)
        self.__motor1Angle = motor1Angle
        motor1AngleRate  = kwargs.pop("motor1AngleRate", None)
        self.__motor1AngleRate = motor1AngleRate
        motor1Axis  = kwargs.pop("motor1Axis", [0, 0, 0])
        self.__motor1Axis = motor1Axis
        motor2Angle  = kwargs.pop("motor2Angle", None)
        self.__motor2Angle = motor2Angle
        motor2AngleRate  = kwargs.pop("motor2AngleRate", None)
        self.__motor2AngleRate = motor2AngleRate
        motor2Axis  = kwargs.pop("motor2Axis", [0, 0, 0])
        self.__motor2Axis = motor2Axis
        motor3Angle  = kwargs.pop("motor3Angle", None)
        self.__motor3Angle = motor3Angle
        motor3AngleRate  = kwargs.pop("motor3AngleRate", None)
        self.__motor3AngleRate = motor3AngleRate
        motor3Axis  = kwargs.pop("motor3Axis", [0, 0, 0])
        self.__motor3Axis = motor3Axis
        stop1Bounce  = kwargs.pop("stop1Bounce", 0)
        self.__stop1Bounce = stop1Bounce
        stop1ErrorCorrection  = kwargs.pop("stop1ErrorCorrection", 0.8)
        self.__stop1ErrorCorrection = stop1ErrorCorrection
        stop2Bounce  = kwargs.pop("stop2Bounce", 0)
        self.__stop2Bounce = stop2Bounce
        stop2ErrorCorrection  = kwargs.pop("stop2ErrorCorrection", 0.8)
        self.__stop2ErrorCorrection = stop2ErrorCorrection
        stop3Bounce  = kwargs.pop("stop3Bounce", 0)
        self.__stop3Bounce = stop3Bounce
        stop3ErrorCorrection  = kwargs.pop("stop3ErrorCorrection", 0.8)
        self.__stop3ErrorCorrection = stop3ErrorCorrection
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def axis1Angle(self):
        return self.__axis1Angle
    @axis1Angle.setter
    def axis1Angle(self, value = 0):
        self.__axis1Angle = [value]
    def setAxis1Angle(self, axis1Angle = 0):
        self.__axis1Angle = [axis1Angle]
        return self
    def addAxis1Angle(self, axis1Angle = 0):
        if self.__axis1Angle == None:            self.__axis1Angle =  []
        self.__axis1Angle +=  [axis1Angle]
        return self
    def removeAxis1Angle(self, axis1Angle):
        self.__axis1Angle = [x for x in self.__axis1Angle if x not in axis1Angle]
        return self.__axis1Angle
    def getAxis1Angle(self, axis1Angle = 0):
        return self.__axis1Angle
    def axis1Angle_changed(self, axis1Angle = 0):
        return self.__axis1Angle
    @property
    def axis1Torque(self):
        return self.__axis1Torque
    @axis1Torque.setter
    def axis1Torque(self, value = 0):
        self.__axis1Torque = [value]
    def setAxis1Torque(self, axis1Torque = 0):
        self.__axis1Torque = [axis1Torque]
        return self
    def addAxis1Torque(self, axis1Torque = 0):
        if self.__axis1Torque == None:            self.__axis1Torque =  []
        self.__axis1Torque +=  [axis1Torque]
        return self
    def removeAxis1Torque(self, axis1Torque):
        self.__axis1Torque = [x for x in self.__axis1Torque if x not in axis1Torque]
        return self.__axis1Torque
    def getAxis1Torque(self, axis1Torque = 0):
        return self.__axis1Torque
    def axis1Torque_changed(self, axis1Torque = 0):
        return self.__axis1Torque
    @property
    def axis2Angle(self):
        return self.__axis2Angle
    @axis2Angle.setter
    def axis2Angle(self, value = 0):
        self.__axis2Angle = [value]
    def setAxis2Angle(self, axis2Angle = 0):
        self.__axis2Angle = [axis2Angle]
        return self
    def addAxis2Angle(self, axis2Angle = 0):
        if self.__axis2Angle == None:            self.__axis2Angle =  []
        self.__axis2Angle +=  [axis2Angle]
        return self
    def removeAxis2Angle(self, axis2Angle):
        self.__axis2Angle = [x for x in self.__axis2Angle if x not in axis2Angle]
        return self.__axis2Angle
    def getAxis2Angle(self, axis2Angle = 0):
        return self.__axis2Angle
    def axis2Angle_changed(self, axis2Angle = 0):
        return self.__axis2Angle
    @property
    def axis2Torque(self):
        return self.__axis2Torque
    @axis2Torque.setter
    def axis2Torque(self, value = 0):
        self.__axis2Torque = [value]
    def setAxis2Torque(self, axis2Torque = 0):
        self.__axis2Torque = [axis2Torque]
        return self
    def addAxis2Torque(self, axis2Torque = 0):
        if self.__axis2Torque == None:            self.__axis2Torque =  []
        self.__axis2Torque +=  [axis2Torque]
        return self
    def removeAxis2Torque(self, axis2Torque):
        self.__axis2Torque = [x for x in self.__axis2Torque if x not in axis2Torque]
        return self.__axis2Torque
    def getAxis2Torque(self, axis2Torque = 0):
        return self.__axis2Torque
    def axis2Torque_changed(self, axis2Torque = 0):
        return self.__axis2Torque
    @property
    def axis3Angle(self):
        return self.__axis3Angle
    @axis3Angle.setter
    def axis3Angle(self, value = 0):
        self.__axis3Angle = [value]
    def setAxis3Angle(self, axis3Angle = 0):
        self.__axis3Angle = [axis3Angle]
        return self
    def addAxis3Angle(self, axis3Angle = 0):
        if self.__axis3Angle == None:            self.__axis3Angle =  []
        self.__axis3Angle +=  [axis3Angle]
        return self
    def removeAxis3Angle(self, axis3Angle):
        self.__axis3Angle = [x for x in self.__axis3Angle if x not in axis3Angle]
        return self.__axis3Angle
    def getAxis3Angle(self, axis3Angle = 0):
        return self.__axis3Angle
    def axis3Angle_changed(self, axis3Angle = 0):
        return self.__axis3Angle
    @property
    def axis3Torque(self):
        return self.__axis3Torque
    @axis3Torque.setter
    def axis3Torque(self, value = 0):
        self.__axis3Torque = [value]
    def setAxis3Torque(self, axis3Torque = 0):
        self.__axis3Torque = [axis3Torque]
        return self
    def addAxis3Torque(self, axis3Torque = 0):
        if self.__axis3Torque == None:            self.__axis3Torque =  []
        self.__axis3Torque +=  [axis3Torque]
        return self
    def removeAxis3Torque(self, axis3Torque):
        self.__axis3Torque = [x for x in self.__axis3Torque if x not in axis3Torque]
        return self.__axis3Torque
    def getAxis3Torque(self, axis3Torque = 0):
        return self.__axis3Torque
    def axis3Torque_changed(self, axis3Torque = 0):
        return self.__axis3Torque
    @property
    def body1(self):
        return self.__body1
    @body1.setter
    def body1(self, value = None):
        self.__body1 = [value]
    def setBody1(self, body1 = None):
        self.__body1 = [body1]
        return self
    def addBody1(self, body1 = None):
        if self.__body1 == None:            self.__body1 =  []
        self.__body1 +=  [body1]
        return self
    def removeBody1(self, body1):
        self.__body1 = [x for x in self.__body1 if x not in body1]
        return self.__body1
    def getBody1(self, body1 = None):
        return self.__body1
    def body1_changed(self, body1 = None):
        return self.__body1
    @property
    def body2(self):
        return self.__body2
    @body2.setter
    def body2(self, value = None):
        self.__body2 = [value]
    def setBody2(self, body2 = None):
        self.__body2 = [body2]
        return self
    def addBody2(self, body2 = None):
        if self.__body2 == None:            self.__body2 =  []
        self.__body2 +=  [body2]
        return self
    def removeBody2(self, body2):
        self.__body2 = [x for x in self.__body2 if x not in body2]
        return self.__body2
    def getBody2(self, body2 = None):
        return self.__body2
    def body2_changed(self, body2 = None):
        return self.__body2
    @property
    def enabledAxes(self):
        return self.__enabledAxes
    @enabledAxes.setter
    def enabledAxes(self, value = 1):
        if value == None or value  <  0:
            return None
        if value == None or value  >  3:
            return None
        self.__enabledAxes = [value]
    def setEnabledAxes(self, enabledAxes = 1):
        if enabledAxes == None or enabledAxes  <  0:
            return None
        if enabledAxes == None or enabledAxes  >  3:
            return None
        self.__enabledAxes = [enabledAxes]
        return self
    def addEnabledAxes(self, enabledAxes = 1):
        if enabledAxes == None or enabledAxes  <  0:
            return None
        if enabledAxes == None or enabledAxes  >  3:
            return None
        if self.__enabledAxes == None:            self.__enabledAxes =  []
        self.__enabledAxes +=  [enabledAxes]
        return self
    def removeEnabledAxes(self, enabledAxes):
        self.__enabledAxes = [x for x in self.__enabledAxes if x not in enabledAxes]
        return self.__enabledAxes
    def getEnabledAxes(self, enabledAxes = 1):
        return self.__enabledAxes
    def enabledAxes_changed(self, enabledAxes = 1):
        return self.__enabledAxes
    @property
    def forceOutput(self):
        return self.__forceOutput
    @forceOutput.setter
    def forceOutput(self, value = ["NONE"]):
        self.__forceOutput = [value]
    def setForceOutput(self, forceOutput = ["NONE"]):
        self.__forceOutput = [forceOutput]
        return self
    def addForceOutput(self, forceOutput = ["NONE"]):
        if self.__forceOutput == None:            self.__forceOutput =  []
        self.__forceOutput +=  [forceOutput]
        return self
    def removeForceOutput(self, forceOutput):
        self.__forceOutput = [x for x in self.__forceOutput if x not in forceOutput]
        return self.__forceOutput
    def getForceOutput(self, forceOutput = ["NONE"]):
        return self.__forceOutput
    def forceOutput_changed(self, forceOutput = ["NONE"]):
        return self.__forceOutput
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    def removeMotor1Angle(self, motor1Angle):
        self.__motor1Angle = [x for x in self.__motor1Angle if x not in motor1Angle]
        return self.__motor1Angle
    def getMotor1Angle(self, motor1Angle = None):
        return self.__motor1Angle
    def motor1Angle_changed(self, motor1Angle = None):
        return self.__motor1Angle
    def removeMotor1AngleRate(self, motor1AngleRate):
        self.__motor1AngleRate = [x for x in self.__motor1AngleRate if x not in motor1AngleRate]
        return self.__motor1AngleRate
    def getMotor1AngleRate(self, motor1AngleRate = None):
        return self.__motor1AngleRate
    def motor1AngleRate_changed(self, motor1AngleRate = None):
        return self.__motor1AngleRate
    @property
    def motor1Axis(self):
        return self.__motor1Axis
    @motor1Axis.setter
    def motor1Axis(self, value = [0, 0, 0]):
        self.__motor1Axis = [value]
    def setMotor1Axis(self, motor1Axis = [0, 0, 0]):
        self.__motor1Axis = [motor1Axis]
        return self
    def addMotor1Axis(self, motor1Axis = [0, 0, 0]):
        if self.__motor1Axis == None:            self.__motor1Axis =  []
        self.__motor1Axis +=  [motor1Axis]
        return self
    def removeMotor1Axis(self, motor1Axis):
        self.__motor1Axis = [x for x in self.__motor1Axis if x not in motor1Axis]
        return self.__motor1Axis
    def getMotor1Axis(self, motor1Axis = [0, 0, 0]):
        return self.__motor1Axis
    def motor1Axis_changed(self, motor1Axis = [0, 0, 0]):
        return self.__motor1Axis
    def removeMotor2Angle(self, motor2Angle):
        self.__motor2Angle = [x for x in self.__motor2Angle if x not in motor2Angle]
        return self.__motor2Angle
    def getMotor2Angle(self, motor2Angle = None):
        return self.__motor2Angle
    def motor2Angle_changed(self, motor2Angle = None):
        return self.__motor2Angle
    def removeMotor2AngleRate(self, motor2AngleRate):
        self.__motor2AngleRate = [x for x in self.__motor2AngleRate if x not in motor2AngleRate]
        return self.__motor2AngleRate
    def getMotor2AngleRate(self, motor2AngleRate = None):
        return self.__motor2AngleRate
    def motor2AngleRate_changed(self, motor2AngleRate = None):
        return self.__motor2AngleRate
    @property
    def motor2Axis(self):
        return self.__motor2Axis
    @motor2Axis.setter
    def motor2Axis(self, value = [0, 0, 0]):
        self.__motor2Axis = [value]
    def setMotor2Axis(self, motor2Axis = [0, 0, 0]):
        self.__motor2Axis = [motor2Axis]
        return self
    def addMotor2Axis(self, motor2Axis = [0, 0, 0]):
        if self.__motor2Axis == None:            self.__motor2Axis =  []
        self.__motor2Axis +=  [motor2Axis]
        return self
    def removeMotor2Axis(self, motor2Axis):
        self.__motor2Axis = [x for x in self.__motor2Axis if x not in motor2Axis]
        return self.__motor2Axis
    def getMotor2Axis(self, motor2Axis = [0, 0, 0]):
        return self.__motor2Axis
    def motor2Axis_changed(self, motor2Axis = [0, 0, 0]):
        return self.__motor2Axis
    def removeMotor3Angle(self, motor3Angle):
        self.__motor3Angle = [x for x in self.__motor3Angle if x not in motor3Angle]
        return self.__motor3Angle
    def getMotor3Angle(self, motor3Angle = None):
        return self.__motor3Angle
    def motor3Angle_changed(self, motor3Angle = None):
        return self.__motor3Angle
    def removeMotor3AngleRate(self, motor3AngleRate):
        self.__motor3AngleRate = [x for x in self.__motor3AngleRate if x not in motor3AngleRate]
        return self.__motor3AngleRate
    def getMotor3AngleRate(self, motor3AngleRate = None):
        return self.__motor3AngleRate
    def motor3AngleRate_changed(self, motor3AngleRate = None):
        return self.__motor3AngleRate
    @property
    def motor3Axis(self):
        return self.__motor3Axis
    @motor3Axis.setter
    def motor3Axis(self, value = [0, 0, 0]):
        self.__motor3Axis = [value]
    def setMotor3Axis(self, motor3Axis = [0, 0, 0]):
        self.__motor3Axis = [motor3Axis]
        return self
    def addMotor3Axis(self, motor3Axis = [0, 0, 0]):
        if self.__motor3Axis == None:            self.__motor3Axis =  []
        self.__motor3Axis +=  [motor3Axis]
        return self
    def removeMotor3Axis(self, motor3Axis):
        self.__motor3Axis = [x for x in self.__motor3Axis if x not in motor3Axis]
        return self.__motor3Axis
    def getMotor3Axis(self, motor3Axis = [0, 0, 0]):
        return self.__motor3Axis
    def motor3Axis_changed(self, motor3Axis = [0, 0, 0]):
        return self.__motor3Axis
    @property
    def stop1Bounce(self):
        return self.__stop1Bounce
    @stop1Bounce.setter
    def stop1Bounce(self, value = 0):
        self.__stop1Bounce = [value]
    def setStop1Bounce(self, stop1Bounce = 0):
        self.__stop1Bounce = [stop1Bounce]
        return self
    def addStop1Bounce(self, stop1Bounce = 0):
        if self.__stop1Bounce == None:            self.__stop1Bounce =  []
        self.__stop1Bounce +=  [stop1Bounce]
        return self
    def removeStop1Bounce(self, stop1Bounce):
        self.__stop1Bounce = [x for x in self.__stop1Bounce if x not in stop1Bounce]
        return self.__stop1Bounce
    def getStop1Bounce(self, stop1Bounce = 0):
        return self.__stop1Bounce
    def stop1Bounce_changed(self, stop1Bounce = 0):
        return self.__stop1Bounce
    @property
    def stop1ErrorCorrection(self):
        return self.__stop1ErrorCorrection
    @stop1ErrorCorrection.setter
    def stop1ErrorCorrection(self, value = 0.8):
        self.__stop1ErrorCorrection = [value]
    def setStop1ErrorCorrection(self, stop1ErrorCorrection = 0.8):
        self.__stop1ErrorCorrection = [stop1ErrorCorrection]
        return self
    def addStop1ErrorCorrection(self, stop1ErrorCorrection = 0.8):
        if self.__stop1ErrorCorrection == None:            self.__stop1ErrorCorrection =  []
        self.__stop1ErrorCorrection +=  [stop1ErrorCorrection]
        return self
    def removeStop1ErrorCorrection(self, stop1ErrorCorrection):
        self.__stop1ErrorCorrection = [x for x in self.__stop1ErrorCorrection if x not in stop1ErrorCorrection]
        return self.__stop1ErrorCorrection
    def getStop1ErrorCorrection(self, stop1ErrorCorrection = 0.8):
        return self.__stop1ErrorCorrection
    def stop1ErrorCorrection_changed(self, stop1ErrorCorrection = 0.8):
        return self.__stop1ErrorCorrection
    @property
    def stop2Bounce(self):
        return self.__stop2Bounce
    @stop2Bounce.setter
    def stop2Bounce(self, value = 0):
        self.__stop2Bounce = [value]
    def setStop2Bounce(self, stop2Bounce = 0):
        self.__stop2Bounce = [stop2Bounce]
        return self
    def addStop2Bounce(self, stop2Bounce = 0):
        if self.__stop2Bounce == None:            self.__stop2Bounce =  []
        self.__stop2Bounce +=  [stop2Bounce]
        return self
    def removeStop2Bounce(self, stop2Bounce):
        self.__stop2Bounce = [x for x in self.__stop2Bounce if x not in stop2Bounce]
        return self.__stop2Bounce
    def getStop2Bounce(self, stop2Bounce = 0):
        return self.__stop2Bounce
    def stop2Bounce_changed(self, stop2Bounce = 0):
        return self.__stop2Bounce
    @property
    def stop2ErrorCorrection(self):
        return self.__stop2ErrorCorrection
    @stop2ErrorCorrection.setter
    def stop2ErrorCorrection(self, value = 0.8):
        self.__stop2ErrorCorrection = [value]
    def setStop2ErrorCorrection(self, stop2ErrorCorrection = 0.8):
        self.__stop2ErrorCorrection = [stop2ErrorCorrection]
        return self
    def addStop2ErrorCorrection(self, stop2ErrorCorrection = 0.8):
        if self.__stop2ErrorCorrection == None:            self.__stop2ErrorCorrection =  []
        self.__stop2ErrorCorrection +=  [stop2ErrorCorrection]
        return self
    def removeStop2ErrorCorrection(self, stop2ErrorCorrection):
        self.__stop2ErrorCorrection = [x for x in self.__stop2ErrorCorrection if x not in stop2ErrorCorrection]
        return self.__stop2ErrorCorrection
    def getStop2ErrorCorrection(self, stop2ErrorCorrection = 0.8):
        return self.__stop2ErrorCorrection
    def stop2ErrorCorrection_changed(self, stop2ErrorCorrection = 0.8):
        return self.__stop2ErrorCorrection
    @property
    def stop3Bounce(self):
        return self.__stop3Bounce
    @stop3Bounce.setter
    def stop3Bounce(self, value = 0):
        self.__stop3Bounce = [value]
    def setStop3Bounce(self, stop3Bounce = 0):
        self.__stop3Bounce = [stop3Bounce]
        return self
    def addStop3Bounce(self, stop3Bounce = 0):
        if self.__stop3Bounce == None:            self.__stop3Bounce =  []
        self.__stop3Bounce +=  [stop3Bounce]
        return self
    def removeStop3Bounce(self, stop3Bounce):
        self.__stop3Bounce = [x for x in self.__stop3Bounce if x not in stop3Bounce]
        return self.__stop3Bounce
    def getStop3Bounce(self, stop3Bounce = 0):
        return self.__stop3Bounce
    def stop3Bounce_changed(self, stop3Bounce = 0):
        return self.__stop3Bounce
    @property
    def stop3ErrorCorrection(self):
        return self.__stop3ErrorCorrection
    @stop3ErrorCorrection.setter
    def stop3ErrorCorrection(self, value = 0.8):
        self.__stop3ErrorCorrection = [value]
    def setStop3ErrorCorrection(self, stop3ErrorCorrection = 0.8):
        self.__stop3ErrorCorrection = [stop3ErrorCorrection]
        return self
    def addStop3ErrorCorrection(self, stop3ErrorCorrection = 0.8):
        if self.__stop3ErrorCorrection == None:            self.__stop3ErrorCorrection =  []
        self.__stop3ErrorCorrection +=  [stop3ErrorCorrection]
        return self
    def removeStop3ErrorCorrection(self, stop3ErrorCorrection):
        self.__stop3ErrorCorrection = [x for x in self.__stop3ErrorCorrection if x not in stop3ErrorCorrection]
        return self.__stop3ErrorCorrection
    def getStop3ErrorCorrection(self, stop3ErrorCorrection = 0.8):
        return self.__stop3ErrorCorrection
    def stop3ErrorCorrection_changed(self, stop3ErrorCorrection = 0.8):
        return self.__stop3ErrorCorrection
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<MotorJoint'
        if self.__autoCalc is not None:
            if isinstance(self.__autoCalc, six.string_types):
                str += ' autoCalc="'+self.__autoCalc+'"'
            else:
                str += ' autoCalc="'+self.__autoCalc[0]+'"'
        if self.__axis1Angle is not None:
            if isinstance(self.__axis1Angle, six.string_types):
                str += ' axis1Angle="'+self.__axis1Angle+'"'
            else:
                str += ' axis1Angle="'+self.__axis1Angle[0]+'"'
        if self.__axis1Torque is not None:
            if isinstance(self.__axis1Torque, six.string_types):
                str += ' axis1Torque="'+self.__axis1Torque+'"'
            else:
                str += ' axis1Torque="'+self.__axis1Torque[0]+'"'
        if self.__axis2Angle is not None:
            if isinstance(self.__axis2Angle, six.string_types):
                str += ' axis2Angle="'+self.__axis2Angle+'"'
            else:
                str += ' axis2Angle="'+self.__axis2Angle[0]+'"'
        if self.__axis2Torque is not None:
            if isinstance(self.__axis2Torque, six.string_types):
                str += ' axis2Torque="'+self.__axis2Torque+'"'
            else:
                str += ' axis2Torque="'+self.__axis2Torque[0]+'"'
        if self.__axis3Angle is not None:
            if isinstance(self.__axis3Angle, six.string_types):
                str += ' axis3Angle="'+self.__axis3Angle+'"'
            else:
                str += ' axis3Angle="'+self.__axis3Angle[0]+'"'
        if self.__axis3Torque is not None:
            if isinstance(self.__axis3Torque, six.string_types):
                str += ' axis3Torque="'+self.__axis3Torque+'"'
            else:
                str += ' axis3Torque="'+self.__axis3Torque[0]+'"'
        if self.__enabledAxes is not None:
            if isinstance(self.__enabledAxes, six.string_types):
                str += ' enabledAxes="'+self.__enabledAxes+'"'
            else:
                str += ' enabledAxes="'+self.__enabledAxes[0]+'"'
        if self.__forceOutput is not None:
            if isinstance(self.__forceOutput, six.string_types):
                str += ' forceOutput="'+self.__forceOutput+'"'
            else:
                str += ' forceOutput="'+self.__forceOutput[0]+'"'
        if self.__motor1Angle is not None:
            if isinstance(self.__motor1Angle, six.string_types):
                str += ' motor1Angle="'+self.__motor1Angle+'"'
            else:
                str += ' motor1Angle="'+self.__motor1Angle[0]+'"'
        if self.__motor1AngleRate is not None:
            if isinstance(self.__motor1AngleRate, six.string_types):
                str += ' motor1AngleRate="'+self.__motor1AngleRate+'"'
            else:
                str += ' motor1AngleRate="'+self.__motor1AngleRate[0]+'"'
        if self.__motor1Axis is not None:
            if isinstance(self.__motor1Axis, six.string_types):
                str += ' motor1Axis="'+self.__motor1Axis+'"'
            else:
                str += ' motor1Axis="'+self.__motor1Axis[0]+'"'
        if self.__motor2Angle is not None:
            if isinstance(self.__motor2Angle, six.string_types):
                str += ' motor2Angle="'+self.__motor2Angle+'"'
            else:
                str += ' motor2Angle="'+self.__motor2Angle[0]+'"'
        if self.__motor2AngleRate is not None:
            if isinstance(self.__motor2AngleRate, six.string_types):
                str += ' motor2AngleRate="'+self.__motor2AngleRate+'"'
            else:
                str += ' motor2AngleRate="'+self.__motor2AngleRate[0]+'"'
        if self.__motor2Axis is not None:
            if isinstance(self.__motor2Axis, six.string_types):
                str += ' motor2Axis="'+self.__motor2Axis+'"'
            else:
                str += ' motor2Axis="'+self.__motor2Axis[0]+'"'
        if self.__motor3Angle is not None:
            if isinstance(self.__motor3Angle, six.string_types):
                str += ' motor3Angle="'+self.__motor3Angle+'"'
            else:
                str += ' motor3Angle="'+self.__motor3Angle[0]+'"'
        if self.__motor3AngleRate is not None:
            if isinstance(self.__motor3AngleRate, six.string_types):
                str += ' motor3AngleRate="'+self.__motor3AngleRate+'"'
            else:
                str += ' motor3AngleRate="'+self.__motor3AngleRate[0]+'"'
        if self.__motor3Axis is not None:
            if isinstance(self.__motor3Axis, six.string_types):
                str += ' motor3Axis="'+self.__motor3Axis+'"'
            else:
                str += ' motor3Axis="'+self.__motor3Axis[0]+'"'
        if self.__stop1Bounce is not None:
            if isinstance(self.__stop1Bounce, six.string_types):
                str += ' stop1Bounce="'+self.__stop1Bounce+'"'
            else:
                str += ' stop1Bounce="'+self.__stop1Bounce[0]+'"'
        if self.__stop1ErrorCorrection is not None:
            if isinstance(self.__stop1ErrorCorrection, six.string_types):
                str += ' stop1ErrorCorrection="'+self.__stop1ErrorCorrection+'"'
            else:
                str += ' stop1ErrorCorrection="'+self.__stop1ErrorCorrection[0]+'"'
        if self.__stop2Bounce is not None:
            if isinstance(self.__stop2Bounce, six.string_types):
                str += ' stop2Bounce="'+self.__stop2Bounce+'"'
            else:
                str += ' stop2Bounce="'+self.__stop2Bounce[0]+'"'
        if self.__stop2ErrorCorrection is not None:
            if isinstance(self.__stop2ErrorCorrection, six.string_types):
                str += ' stop2ErrorCorrection="'+self.__stop2ErrorCorrection+'"'
            else:
                str += ' stop2ErrorCorrection="'+self.__stop2ErrorCorrection[0]+'"'
        if self.__stop3Bounce is not None:
            if isinstance(self.__stop3Bounce, six.string_types):
                str += ' stop3Bounce="'+self.__stop3Bounce+'"'
            else:
                str += ' stop3Bounce="'+self.__stop3Bounce[0]+'"'
        if self.__stop3ErrorCorrection is not None:
            if isinstance(self.__stop3ErrorCorrection, six.string_types):
                str += ' stop3ErrorCorrection="'+self.__stop3ErrorCorrection+'"'
            else:
                str += ' stop3ErrorCorrection="'+self.__stop3ErrorCorrection[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<body1'
        if self.__body1 is not None:
           for s in self.__body1:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__body1 is not None:
           for s in self.__body1:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</body1>'
        str += '<body2'
        if self.__body2 is not None:
           for s in self.__body2:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__body2 is not None:
           for s in self.__body2:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</body2>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</MotorJoint>'
        return str


class MovieTexture(X3DTexture2DNode, X3DUrlObject, X3DSoundSourceNode):
    def __init__(self, **kwargs):
        super(MovieTexture, self).__init__(**kwargs)
        description  = kwargs.pop("description", None)
        self.__description = description
        duration_changed  = kwargs.pop("duration_changed", None)
        if duration_changed == None or duration_changed  <  -1:
            return None
        self.__duration_changed = duration_changed
        elapsedTime  = kwargs.pop("elapsedTime", None)
        if elapsedTime == None or elapsedTime  <  0:
            return None
        self.__elapsedTime = elapsedTime
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        Paused  = kwargs.pop("Paused", None)
        self.__Paused = Paused
        loop  = kwargs.pop("loop", False)
        self.__loop = loop
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        pauseTime  = kwargs.pop("pauseTime", 0)
        self.__pauseTime = pauseTime
        pitch  = kwargs.pop("pitch", 1.0)
        if pitch == None or pitch  <=  0:
            return None
        self.__pitch = pitch
        repeatS  = kwargs.pop("repeatS", True)
        self.__repeatS = repeatS
        repeatT  = kwargs.pop("repeatT", True)
        self.__repeatT = repeatT
        resumeTime  = kwargs.pop("resumeTime", 0)
        self.__resumeTime = resumeTime
        speed  = kwargs.pop("speed", 1.0)
        self.__speed = speed
        startTime  = kwargs.pop("startTime", 0)
        self.__startTime = startTime
        stopTime  = kwargs.pop("stopTime", 0)
        self.__stopTime = stopTime
        textureProperties  = kwargs.pop("textureProperties", None)
        self.__textureProperties = textureProperties
        url  = kwargs.pop("url", None)
        self.__url = url
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def description(self):
        return self.__description
    @description.setter
    def description(self, value = None):
        self.__description = [value]
    def setDescription(self, description = None):
        self.__description = [description]
        return self
    def addDescription(self, description = None):
        if self.__description == None:            self.__description =  []
        self.__description +=  [description]
        return self
    def removeDescription(self, description):
        self.__description = [x for x in self.__description if x not in description]
        return self.__description
    def getDescription(self, description = None):
        return self.__description
    def description_changed(self, description = None):
        return self.__description
    def removeduration_changed(self, duration_changed):
        self.__duration_changed = [x for x in self.__duration_changed if x not in duration_changed]
        return self.__duration_changed
    def getduration_changed(self, duration_changed = None):
        return self.__duration_changed
    def duration_changed_changed(self, duration_changed = None):
        return self.__duration_changed
    def removeElapsedTime(self, elapsedTime):
        self.__elapsedTime = [x for x in self.__elapsedTime if x not in elapsedTime]
        return self.__elapsedTime
    def getElapsedTime(self, elapsedTime = None):
        return self.__elapsedTime
    def elapsedTime_changed(self, elapsedTime = None):
        return self.__elapsedTime
    def isActive(self, Active = None):
        return self.__Active
    def isPaused(self, Paused = None):
        return self.__Paused
    @property
    def loop(self):
        return self.__loop
    @loop.setter
    def loop(self, value = False):
        self.__loop = [value]
    def setLoop(self, loop = False):
        self.__loop = [loop]
        return self
    def addLoop(self, loop = False):
        if self.__loop == None:            self.__loop =  []
        self.__loop +=  [loop]
        return self
    def removeLoop(self, loop):
        self.__loop = [x for x in self.__loop if x not in loop]
        return self.__loop
    def isLoop(self, loop = False):
        return self.__loop
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def pauseTime(self):
        return self.__pauseTime
    @pauseTime.setter
    def pauseTime(self, value = 0):
        self.__pauseTime = [value]
    def setPauseTime(self, pauseTime = 0):
        self.__pauseTime = [pauseTime]
        return self
    def addPauseTime(self, pauseTime = 0):
        if self.__pauseTime == None:            self.__pauseTime =  []
        self.__pauseTime +=  [pauseTime]
        return self
    def removePauseTime(self, pauseTime):
        self.__pauseTime = [x for x in self.__pauseTime if x not in pauseTime]
        return self.__pauseTime
    def getPauseTime(self, pauseTime = 0):
        return self.__pauseTime
    def pauseTime_changed(self, pauseTime = 0):
        return self.__pauseTime
    @property
    def pitch(self):
        return self.__pitch
    @pitch.setter
    def pitch(self, value = 1.0):
        if value == None or value  <=  0:
            return None
        self.__pitch = [value]
    def setPitch(self, pitch = 1.0):
        if pitch == None or pitch  <=  0:
            return None
        self.__pitch = [pitch]
        return self
    def addPitch(self, pitch = 1.0):
        if pitch == None or pitch  <=  0:
            return None
        if self.__pitch == None:            self.__pitch =  []
        self.__pitch +=  [pitch]
        return self
    def removePitch(self, pitch):
        self.__pitch = [x for x in self.__pitch if x not in pitch]
        return self.__pitch
    def getPitch(self, pitch = 1.0):
        return self.__pitch
    def pitch_changed(self, pitch = 1.0):
        return self.__pitch
    @property
    def resumeTime(self):
        return self.__resumeTime
    @resumeTime.setter
    def resumeTime(self, value = 0):
        self.__resumeTime = [value]
    def setResumeTime(self, resumeTime = 0):
        self.__resumeTime = [resumeTime]
        return self
    def addResumeTime(self, resumeTime = 0):
        if self.__resumeTime == None:            self.__resumeTime =  []
        self.__resumeTime +=  [resumeTime]
        return self
    def removeResumeTime(self, resumeTime):
        self.__resumeTime = [x for x in self.__resumeTime if x not in resumeTime]
        return self.__resumeTime
    def getResumeTime(self, resumeTime = 0):
        return self.__resumeTime
    def resumeTime_changed(self, resumeTime = 0):
        return self.__resumeTime
    @property
    def speed(self):
        return self.__speed
    @speed.setter
    def speed(self, value = 1.0):
        self.__speed = [value]
    def setSpeed(self, speed = 1.0):
        self.__speed = [speed]
        return self
    def addSpeed(self, speed = 1.0):
        if self.__speed == None:            self.__speed =  []
        self.__speed +=  [speed]
        return self
    def removeSpeed(self, speed):
        self.__speed = [x for x in self.__speed if x not in speed]
        return self.__speed
    def getSpeed(self, speed = 1.0):
        return self.__speed
    def speed_changed(self, speed = 1.0):
        return self.__speed
    @property
    def startTime(self):
        return self.__startTime
    @startTime.setter
    def startTime(self, value = 0):
        self.__startTime = [value]
    def setStartTime(self, startTime = 0):
        self.__startTime = [startTime]
        return self
    def addStartTime(self, startTime = 0):
        if self.__startTime == None:            self.__startTime =  []
        self.__startTime +=  [startTime]
        return self
    def removeStartTime(self, startTime):
        self.__startTime = [x for x in self.__startTime if x not in startTime]
        return self.__startTime
    def getStartTime(self, startTime = 0):
        return self.__startTime
    def startTime_changed(self, startTime = 0):
        return self.__startTime
    @property
    def stopTime(self):
        return self.__stopTime
    @stopTime.setter
    def stopTime(self, value = 0):
        self.__stopTime = [value]
    def setStopTime(self, stopTime = 0):
        self.__stopTime = [stopTime]
        return self
    def addStopTime(self, stopTime = 0):
        if self.__stopTime == None:            self.__stopTime =  []
        self.__stopTime +=  [stopTime]
        return self
    def removeStopTime(self, stopTime):
        self.__stopTime = [x for x in self.__stopTime if x not in stopTime]
        return self.__stopTime
    def getStopTime(self, stopTime = 0):
        return self.__stopTime
    def stopTime_changed(self, stopTime = 0):
        return self.__stopTime
    @property
    def url(self):
        return self.__url
    @url.setter
    def url(self, value = None):
        self.__url = [value]
    def setUrl(self, url = None):
        self.__url = [url]
        return self
    def addUrl(self, url = None):
        if self.__url == None:            self.__url =  []
        self.__url +=  [url]
        return self
    def removeUrl(self, url):
        self.__url = [x for x in self.__url if x not in url]
        return self.__url
    def getUrl(self, url = None):
        return self.__url
    def url_changed(self, url = None):
        return self.__url
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<MovieTexture'
        if self.__description is not None:
            if isinstance(self.__description, six.string_types):
                str += ' description="'+self.__description+'"'
            else:
                str += ' description="'+self.__description[0]+'"'
        if self.__duration_changed is not None:
            if isinstance(self.__duration_changed, six.string_types):
                str += ' duration_changed="'+self.__duration_changed+'"'
            else:
                str += ' duration_changed="'+self.__duration_changed[0]+'"'
        if self.__elapsedTime is not None:
            if isinstance(self.__elapsedTime, six.string_types):
                str += ' elapsedTime="'+self.__elapsedTime+'"'
            else:
                str += ' elapsedTime="'+self.__elapsedTime[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__Paused is not None:
            if isinstance(self.__Paused, six.string_types):
                str += ' Paused="'+self.__Paused+'"'
            else:
                str += ' Paused="'+self.__Paused[0]+'"'
        if self.__loop is not None:
            if isinstance(self.__loop, six.string_types):
                str += ' loop="'+self.__loop+'"'
            else:
                str += ' loop="'+self.__loop[0]+'"'
        if self.__pauseTime is not None:
            if isinstance(self.__pauseTime, six.string_types):
                str += ' pauseTime="'+self.__pauseTime+'"'
            else:
                str += ' pauseTime="'+self.__pauseTime[0]+'"'
        if self.__pitch is not None:
            if isinstance(self.__pitch, six.string_types):
                str += ' pitch="'+self.__pitch+'"'
            else:
                str += ' pitch="'+self.__pitch[0]+'"'
        if self.__repeatS is not None:
            if isinstance(self.__repeatS, six.string_types):
                str += ' repeatS="'+self.__repeatS+'"'
            else:
                str += ' repeatS="'+self.__repeatS[0]+'"'
        if self.__repeatT is not None:
            if isinstance(self.__repeatT, six.string_types):
                str += ' repeatT="'+self.__repeatT+'"'
            else:
                str += ' repeatT="'+self.__repeatT[0]+'"'
        if self.__resumeTime is not None:
            if isinstance(self.__resumeTime, six.string_types):
                str += ' resumeTime="'+self.__resumeTime+'"'
            else:
                str += ' resumeTime="'+self.__resumeTime[0]+'"'
        if self.__speed is not None:
            if isinstance(self.__speed, six.string_types):
                str += ' speed="'+self.__speed+'"'
            else:
                str += ' speed="'+self.__speed[0]+'"'
        if self.__startTime is not None:
            if isinstance(self.__startTime, six.string_types):
                str += ' startTime="'+self.__startTime+'"'
            else:
                str += ' startTime="'+self.__startTime[0]+'"'
        if self.__stopTime is not None:
            if isinstance(self.__stopTime, six.string_types):
                str += ' stopTime="'+self.__stopTime+'"'
            else:
                str += ' stopTime="'+self.__stopTime[0]+'"'
        if self.__url is not None:
            if isinstance(self.__url, six.string_types):
                str += ' url="'+self.__url+'"'
            else:
                str += ' url="'+self.__url[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<textureProperties'
        if self.__textureProperties is not None:
           for s in self.__textureProperties:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__textureProperties is not None:
           for s in self.__textureProperties:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</textureProperties>'
        str += '</MovieTexture>'
        return str


class MultiTexture(X3DTextureNode):
    def __init__(self, **kwargs):
        super(MultiTexture, self).__init__(**kwargs)
        alpha  = kwargs.pop("alpha", 1)
        if alpha == None or alpha  <  0:
            return None
        if alpha == None or alpha  >  1:
            return None
        self.__alpha = alpha
        color  = kwargs.pop("color", [1, 1, 1])
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        self.__color = color
        function  = kwargs.pop("function", None)
        self.__function = function
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        mode  = kwargs.pop("mode", None)
        self.__mode = mode
        source  = kwargs.pop("source", None)
        self.__source = source
        texture  = kwargs.pop("texture", None)
        self.__texture = texture
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def alpha(self):
        return self.__alpha
    @alpha.setter
    def alpha(self, value = 1):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__alpha = [value]
    def setAlpha(self, alpha = 1):
        if alpha == None or alpha  <  0:
            return None
        if alpha == None or alpha  >  1:
            return None
        self.__alpha = [alpha]
        return self
    def addAlpha(self, alpha = 1):
        if alpha == None or alpha  <  0:
            return None
        if alpha == None or alpha  >  1:
            return None
        if self.__alpha == None:            self.__alpha =  []
        self.__alpha +=  [alpha]
        return self
    def removeAlpha(self, alpha):
        self.__alpha = [x for x in self.__alpha if x not in alpha]
        return self.__alpha
    def getAlpha(self, alpha = 1):
        return self.__alpha
    def alpha_changed(self, alpha = 1):
        return self.__alpha
    @property
    def color(self):
        return self.__color
    @color.setter
    def color(self, value = [1, 1, 1]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__color = [value]
    def setColor(self, color = [1, 1, 1]):
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        self.__color = [color]
        return self
    def addColor(self, color = [1, 1, 1]):
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        if self.__color == None:            self.__color =  []
        self.__color +=  [color]
        return self
    def removeColor(self, color):
        self.__color = [x for x in self.__color if x not in color]
        return self.__color
    def getColor(self, color = [1, 1, 1]):
        return self.__color
    def color_changed(self, color = [1, 1, 1]):
        return self.__color
    @property
    def function(self):
        return self.__function
    @function.setter
    def function(self, value = None):
        self.__function = [value]
    def setFunction(self, function = None):
        self.__function = [function]
        return self
    def addFunction(self, function = None):
        if self.__function == None:            self.__function =  []
        self.__function +=  [function]
        return self
    def removeFunction(self, function):
        self.__function = [x for x in self.__function if x not in function]
        return self.__function
    def getFunction(self, function = None):
        return self.__function
    def function_changed(self, function = None):
        return self.__function
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def mode(self):
        return self.__mode
    @mode.setter
    def mode(self, value = None):
        self.__mode = [value]
    def setMode(self, mode = None):
        self.__mode = [mode]
        return self
    def addMode(self, mode = None):
        if self.__mode == None:            self.__mode =  []
        self.__mode +=  [mode]
        return self
    def removeMode(self, mode):
        self.__mode = [x for x in self.__mode if x not in mode]
        return self.__mode
    def getMode(self, mode = None):
        return self.__mode
    def mode_changed(self, mode = None):
        return self.__mode
    @property
    def source(self):
        return self.__source
    @source.setter
    def source(self, value = None):
        self.__source = [value]
    def setSource(self, source = None):
        self.__source = [source]
        return self
    def addSource(self, source = None):
        if self.__source == None:            self.__source =  []
        self.__source +=  [source]
        return self
    def removeSource(self, source):
        self.__source = [x for x in self.__source if x not in source]
        return self.__source
    def getSource(self, source = None):
        return self.__source
    def source_changed(self, source = None):
        return self.__source
    @property
    def texture(self):
        return self.__texture
    @texture.setter
    def texture(self, value = None):
        self.__texture = [value]
    def setTexture(self, texture = None):
        self.__texture = [texture]
        return self
    def addTexture(self, texture = None):
        if self.__texture == None:            self.__texture =  []
        self.__texture +=  [texture]
        return self
    def removeTexture(self, texture):
        self.__texture = [x for x in self.__texture if x not in texture]
        return self.__texture
    def getTexture(self, texture = None):
        return self.__texture
    def texture_changed(self, texture = None):
        return self.__texture
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<MultiTexture'
        if self.__alpha is not None:
            if isinstance(self.__alpha, six.string_types):
                str += ' alpha="'+self.__alpha+'"'
            else:
                str += ' alpha="'+self.__alpha[0]+'"'
        if self.__color is not None:
            if isinstance(self.__color, six.string_types):
                str += ' color="'+self.__color+'"'
            else:
                str += ' color="'+self.__color[0]+'"'
        if self.__function is not None:
            if isinstance(self.__function, six.string_types):
                str += ' function="'+self.__function+'"'
            else:
                str += ' function="'+self.__function[0]+'"'
        if self.__mode is not None:
            if isinstance(self.__mode, six.string_types):
                str += ' mode="'+self.__mode+'"'
            else:
                str += ' mode="'+self.__mode[0]+'"'
        if self.__source is not None:
            if isinstance(self.__source, six.string_types):
                str += ' source="'+self.__source+'"'
            else:
                str += ' source="'+self.__source[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<texture'
        if self.__texture is not None:
           for s in self.__texture:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__texture is not None:
           for s in self.__texture:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</texture>'
        str += '</MultiTexture>'
        return str


class MultiTextureCoordinate(X3DTextureCoordinateNode):
    def __init__(self, **kwargs):
        super(MultiTextureCoordinate, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        texCoord  = kwargs.pop("texCoord", None)
        self.__texCoord = texCoord
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def texCoord(self):
        return self.__texCoord
    @texCoord.setter
    def texCoord(self, value = None):
        self.__texCoord = [value]
    def setTexCoord(self, texCoord = None):
        self.__texCoord = [texCoord]
        return self
    def addTexCoord(self, texCoord = None):
        if self.__texCoord == None:            self.__texCoord =  []
        self.__texCoord +=  [texCoord]
        return self
    def removeTexCoord(self, texCoord):
        self.__texCoord = [x for x in self.__texCoord if x not in texCoord]
        return self.__texCoord
    def getTexCoord(self, texCoord = None):
        return self.__texCoord
    def texCoord_changed(self, texCoord = None):
        return self.__texCoord
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<MultiTextureCoordinate'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<texCoord'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</texCoord>'
        str += '</MultiTextureCoordinate>'
        return str


class MultiTextureTransform(X3DTextureTransformNode):
    def __init__(self, **kwargs):
        super(MultiTextureTransform, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        textureTransform  = kwargs.pop("textureTransform", None)
        self.__textureTransform = textureTransform
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def textureTransform(self):
        return self.__textureTransform
    @textureTransform.setter
    def textureTransform(self, value = None):
        self.__textureTransform = [value]
    def setTextureTransform(self, textureTransform = None):
        self.__textureTransform = [textureTransform]
        return self
    def addTextureTransform(self, textureTransform = None):
        if self.__textureTransform == None:            self.__textureTransform =  []
        self.__textureTransform +=  [textureTransform]
        return self
    def removeTextureTransform(self, textureTransform):
        self.__textureTransform = [x for x in self.__textureTransform if x not in textureTransform]
        return self.__textureTransform
    def getTextureTransform(self, textureTransform = None):
        return self.__textureTransform
    def textureTransform_changed(self, textureTransform = None):
        return self.__textureTransform
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<MultiTextureTransform'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<textureTransform'
        if self.__textureTransform is not None:
           for s in self.__textureTransform:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__textureTransform is not None:
           for s in self.__textureTransform:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</textureTransform>'
        str += '</MultiTextureTransform>'
        return str


class NavigationInfo(X3DBindableNode):
    def __init__(self, **kwargs):
        super(NavigationInfo, self).__init__(**kwargs)
        avatarSize  = kwargs.pop("avatarSize", [0.25, 1.6, 0.75])
        if avatarSize == None or len(avatarSize) <= 0 or min(avatarSize)  <  0:
            return None
        self.__avatarSize = avatarSize
        bindTime  = kwargs.pop("bindTime", None)
        self.__bindTime = bindTime
        headlight  = kwargs.pop("headlight", True)
        self.__headlight = headlight
        Bound  = kwargs.pop("Bound", None)
        self.__Bound = Bound
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        bind  = kwargs.pop("bind", None)
        self.__bind = bind
        speed  = kwargs.pop("speed", 1)
        if speed == None or speed  <  0:
            return None
        self.__speed = speed
        transitionComplete  = kwargs.pop("transitionComplete", None)
        self.__transitionComplete = transitionComplete
        transitionTime  = kwargs.pop("transitionTime", 1.0)
        if transitionTime == None or transitionTime  <  0:
            return None
        self.__transitionTime = transitionTime
        transitionType  = kwargs.pop("transitionType", ["LINEAR"])
        self.__transitionType = transitionType
        type  = kwargs.pop("type", ["EXAMINE", "ANY"])
        self.__type = type
        visibilityLimit  = kwargs.pop("visibilityLimit", 0)
        if visibilityLimit == None or visibilityLimit  <  0:
            return None
        self.__visibilityLimit = visibilityLimit
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def avatarSize(self):
        return self.__avatarSize
    @avatarSize.setter
    def avatarSize(self, value = [0.25, 1.6, 0.75]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        self.__avatarSize = [value]
    def setAvatarSize(self, avatarSize = [0.25, 1.6, 0.75]):
        if avatarSize == None or len(avatarSize) <= 0 or min(avatarSize)  <  0:
            return None
        self.__avatarSize = [avatarSize]
        return self
    def addAvatarSize(self, avatarSize = [0.25, 1.6, 0.75]):
        if avatarSize == None or len(avatarSize) <= 0 or min(avatarSize)  <  0:
            return None
        if self.__avatarSize == None:            self.__avatarSize =  []
        self.__avatarSize +=  [avatarSize]
        return self
    def removeAvatarSize(self, avatarSize):
        self.__avatarSize = [x for x in self.__avatarSize if x not in avatarSize]
        return self.__avatarSize
    def getAvatarSize(self, avatarSize = [0.25, 1.6, 0.75]):
        return self.__avatarSize
    def avatarSize_changed(self, avatarSize = [0.25, 1.6, 0.75]):
        return self.__avatarSize
    def removeBindTime(self, bindTime):
        self.__bindTime = [x for x in self.__bindTime if x not in bindTime]
        return self.__bindTime
    def getBindTime(self, bindTime = None):
        return self.__bindTime
    def bindTime_changed(self, bindTime = None):
        return self.__bindTime
    @property
    def headlight(self):
        return self.__headlight
    @headlight.setter
    def headlight(self, value = True):
        self.__headlight = [value]
    def setHeadlight(self, headlight = True):
        self.__headlight = [headlight]
        return self
    def addHeadlight(self, headlight = True):
        if self.__headlight == None:            self.__headlight =  []
        self.__headlight +=  [headlight]
        return self
    def removeHeadlight(self, headlight):
        self.__headlight = [x for x in self.__headlight if x not in headlight]
        return self.__headlight
    def isHeadlight(self, headlight = True):
        return self.__headlight
    def isBound(self, Bound = None):
        return self.__Bound
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def bind(self):
        return self.__bind
    @bind.setter
    def bind(self, value = None):
        self.__bind = [value]
    def set_bind(self, bind = None):
        self.__bind = [bind]
        return self
    @property
    def speed(self):
        return self.__speed
    @speed.setter
    def speed(self, value = 1):
        if value == None or value  <  0:
            return None
        self.__speed = [value]
    def setSpeed(self, speed = 1):
        if speed == None or speed  <  0:
            return None
        self.__speed = [speed]
        return self
    def addSpeed(self, speed = 1):
        if speed == None or speed  <  0:
            return None
        if self.__speed == None:            self.__speed =  []
        self.__speed +=  [speed]
        return self
    def removeSpeed(self, speed):
        self.__speed = [x for x in self.__speed if x not in speed]
        return self.__speed
    def getSpeed(self, speed = 1):
        return self.__speed
    def speed_changed(self, speed = 1):
        return self.__speed
    def removeTransitionComplete(self, transitionComplete):
        self.__transitionComplete = [x for x in self.__transitionComplete if x not in transitionComplete]
        return self.__transitionComplete
    def isTransitionComplete(self, transitionComplete = None):
        return self.__transitionComplete
    @property
    def transitionTime(self):
        return self.__transitionTime
    @transitionTime.setter
    def transitionTime(self, value = 1.0):
        if value == None or value  <  0:
            return None
        self.__transitionTime = [value]
    def setTransitionTime(self, transitionTime = 1.0):
        if transitionTime == None or transitionTime  <  0:
            return None
        self.__transitionTime = [transitionTime]
        return self
    def addTransitionTime(self, transitionTime = 1.0):
        if transitionTime == None or transitionTime  <  0:
            return None
        if self.__transitionTime == None:            self.__transitionTime =  []
        self.__transitionTime +=  [transitionTime]
        return self
    def removeTransitionTime(self, transitionTime):
        self.__transitionTime = [x for x in self.__transitionTime if x not in transitionTime]
        return self.__transitionTime
    def getTransitionTime(self, transitionTime = 1.0):
        return self.__transitionTime
    def transitionTime_changed(self, transitionTime = 1.0):
        return self.__transitionTime
    @property
    def transitionType(self):
        return self.__transitionType
    @transitionType.setter
    def transitionType(self, value = ["LINEAR"]):
        self.__transitionType = [value]
    def setTransitionType(self, transitionType = ["LINEAR"]):
        self.__transitionType = [transitionType]
        return self
    def addTransitionType(self, transitionType = ["LINEAR"]):
        if self.__transitionType == None:            self.__transitionType =  []
        self.__transitionType +=  [transitionType]
        return self
    def removeTransitionType(self, transitionType):
        self.__transitionType = [x for x in self.__transitionType if x not in transitionType]
        return self.__transitionType
    def getTransitionType(self, transitionType = ["LINEAR"]):
        return self.__transitionType
    def transitionType_changed(self, transitionType = ["LINEAR"]):
        return self.__transitionType
    @property
    def type(self):
        return self.__type
    @type.setter
    def type(self, value = ["EXAMINE", "ANY"]):
        self.__type = [value]
    def setType(self, type = ["EXAMINE", "ANY"]):
        self.__type = [type]
        return self
    def addType(self, type = ["EXAMINE", "ANY"]):
        if self.__type == None:            self.__type =  []
        self.__type +=  [type]
        return self
    def removeType(self, type):
        self.__type = [x for x in self.__type if x not in type]
        return self.__type
    def getType(self, type = ["EXAMINE", "ANY"]):
        return self.__type
    def type_changed(self, type = ["EXAMINE", "ANY"]):
        return self.__type
    @property
    def visibilityLimit(self):
        return self.__visibilityLimit
    @visibilityLimit.setter
    def visibilityLimit(self, value = 0):
        if value == None or value  <  0:
            return None
        self.__visibilityLimit = [value]
    def setVisibilityLimit(self, visibilityLimit = 0):
        if visibilityLimit == None or visibilityLimit  <  0:
            return None
        self.__visibilityLimit = [visibilityLimit]
        return self
    def addVisibilityLimit(self, visibilityLimit = 0):
        if visibilityLimit == None or visibilityLimit  <  0:
            return None
        if self.__visibilityLimit == None:            self.__visibilityLimit =  []
        self.__visibilityLimit +=  [visibilityLimit]
        return self
    def removeVisibilityLimit(self, visibilityLimit):
        self.__visibilityLimit = [x for x in self.__visibilityLimit if x not in visibilityLimit]
        return self.__visibilityLimit
    def getVisibilityLimit(self, visibilityLimit = 0):
        return self.__visibilityLimit
    def visibilityLimit_changed(self, visibilityLimit = 0):
        return self.__visibilityLimit
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    @property
    def IS(self):
        return self.__IS
    @IS.setter
    def IS(self, value = None):
        self.__IS = [value]
    def setIS(self, IS = None):
        self.__IS = [IS]
        return self
    def addIS(self, IS = None):
        if self.__IS == None:            self.__IS =  []
        self.__IS +=  [IS]
        return self
    def removeIS(self, IS):
        self.__IS = [x for x in self.__IS if x not in IS]
        return self.__IS
    def getIS(self, IS = None):
        return self.__IS
    def IS_changed(self, IS = None):
        return self.__IS
    def toXML(self):
        str = ''
        str += '<NavigationInfo'
        if self.__avatarSize is not None:
            if isinstance(self.__avatarSize, six.string_types):
                str += ' avatarSize="'+self.__avatarSize+'"'
            else:
                str += ' avatarSize="'+self.__avatarSize[0]+'"'
        if self.__bindTime is not None:
            if isinstance(self.__bindTime, six.string_types):
                str += ' bindTime="'+self.__bindTime+'"'
            else:
                str += ' bindTime="'+self.__bindTime[0]+'"'
        if self.__headlight is not None:
            if isinstance(self.__headlight, six.string_types):
                str += ' headlight="'+self.__headlight+'"'
            else:
                str += ' headlight="'+self.__headlight[0]+'"'
        if self.__Bound is not None:
            if isinstance(self.__Bound, six.string_types):
                str += ' Bound="'+self.__Bound+'"'
            else:
                str += ' Bound="'+self.__Bound[0]+'"'
        if self.__bind is not None:
            if isinstance(self.__bind, six.string_types):
                str += ' bind="'+self.__bind+'"'
            else:
                str += ' bind="'+self.__bind[0]+'"'
        if self.__speed is not None:
            if isinstance(self.__speed, six.string_types):
                str += ' speed="'+self.__speed+'"'
            else:
                str += ' speed="'+self.__speed[0]+'"'
        if self.__transitionComplete is not None:
            if isinstance(self.__transitionComplete, six.string_types):
                str += ' transitionComplete="'+self.__transitionComplete+'"'
            else:
                str += ' transitionComplete="'+self.__transitionComplete[0]+'"'
        if self.__transitionTime is not None:
            if isinstance(self.__transitionTime, six.string_types):
                str += ' transitionTime="'+self.__transitionTime+'"'
            else:
                str += ' transitionTime="'+self.__transitionTime[0]+'"'
        if self.__transitionType is not None:
            if isinstance(self.__transitionType, six.string_types):
                str += ' transitionType="'+self.__transitionType+'"'
            else:
                str += ' transitionType="'+self.__transitionType[0]+'"'
        if self.__type is not None:
            if isinstance(self.__type, six.string_types):
                str += ' type="'+self.__type+'"'
            else:
                str += ' type="'+self.__type[0]+'"'
        if self.__visibilityLimit is not None:
            if isinstance(self.__visibilityLimit, six.string_types):
                str += ' visibilityLimit="'+self.__visibilityLimit+'"'
            else:
                str += ' visibilityLimit="'+self.__visibilityLimit[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</NavigationInfo>'
        return str


class Normal(X3DNormalNode):
    def __init__(self, **kwargs):
        super(Normal, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        vector  = kwargs.pop("vector", None)
        if vector == None or len(vector) <= 0 or min(vector)  <  -1:
            return None
        if vector == None or len(vector) <= 0 or max(vector)  >  1:
            return None
        self.__vector = vector
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def vector(self):
        return self.__vector
    @vector.setter
    def vector(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  -1:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__vector = [value]
    def setVector(self, vector = None):
        if vector == None or len(vector) <= 0 or min(vector)  <  -1:
            return None
        if vector == None or len(vector) <= 0 or max(vector)  >  1:
            return None
        self.__vector = [vector]
        return self
    def addVector(self, vector = None):
        if vector == None or len(vector) <= 0 or min(vector)  <  -1:
            return None
        if vector == None or len(vector) <= 0 or max(vector)  >  1:
            return None
        if self.__vector == None:            self.__vector =  []
        self.__vector +=  [vector]
        return self
    def removeVector(self, vector):
        self.__vector = [x for x in self.__vector if x not in vector]
        return self.__vector
    def getVector(self, vector = None):
        return self.__vector
    def vector_changed(self, vector = None):
        return self.__vector
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Normal'
        if self.__vector is not None:
            if isinstance(self.__vector, six.string_types):
                str += ' vector="'+self.__vector+'"'
            else:
                str += ' vector="'+self.__vector[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</Normal>'
        return str


class NormalInterpolator(X3DInterpolatorNode):
    def __init__(self, **kwargs):
        super(NormalInterpolator, self).__init__(**kwargs)
        key  = kwargs.pop("key", None)
        self.__key = key
        keyValue  = kwargs.pop("keyValue", None)
        self.__keyValue = keyValue
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        fraction  = kwargs.pop("fraction", None)
        self.__fraction = fraction
        value_changed  = kwargs.pop("value_changed", None)
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def key(self):
        return self.__key
    @key.setter
    def key(self, value = None):
        self.__key = [value]
    def setKey(self, key = None):
        self.__key = [key]
        return self
    def addKey(self, key = None):
        if self.__key == None:            self.__key =  []
        self.__key +=  [key]
        return self
    def removeKey(self, key):
        self.__key = [x for x in self.__key if x not in key]
        return self.__key
    def getKey(self, key = None):
        return self.__key
    def key_changed(self, key = None):
        return self.__key
    @property
    def keyValue(self):
        return self.__keyValue
    @keyValue.setter
    def keyValue(self, value = None):
        self.__keyValue = [value]
    def setKeyValue(self, keyValue = None):
        self.__keyValue = [keyValue]
        return self
    def addKeyValue(self, keyValue = None):
        if self.__keyValue == None:            self.__keyValue =  []
        self.__keyValue +=  [keyValue]
        return self
    def removeKeyValue(self, keyValue):
        self.__keyValue = [x for x in self.__keyValue if x not in keyValue]
        return self.__keyValue
    def getKeyValue(self, keyValue = None):
        return self.__keyValue
    def keyValue_changed(self, keyValue = None):
        return self.__keyValue
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def fraction(self):
        return self.__fraction
    @fraction.setter
    def fraction(self, value = None):
        self.__fraction = [value]
    def set_fraction(self, fraction = None):
        self.__fraction = [fraction]
        return self
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<NormalInterpolator'
        if self.__key is not None:
            if isinstance(self.__key, six.string_types):
                str += ' key="'+self.__key+'"'
            else:
                str += ' key="'+self.__key[0]+'"'
        if self.__keyValue is not None:
            if isinstance(self.__keyValue, six.string_types):
                str += ' keyValue="'+self.__keyValue+'"'
            else:
                str += ' keyValue="'+self.__keyValue[0]+'"'
        if self.__fraction is not None:
            if isinstance(self.__fraction, six.string_types):
                str += ' fraction="'+self.__fraction+'"'
            else:
                str += ' fraction="'+self.__fraction[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</NormalInterpolator>'
        return str


class NurbsCurve(X3DParametricGeometryNode):
    def __init__(self, **kwargs):
        super(NurbsCurve, self).__init__(**kwargs)
        closed  = kwargs.pop("closed", False)
        self.__closed = closed
        controlPoint  = kwargs.pop("controlPoint", None)
        self.__controlPoint = controlPoint
        knot  = kwargs.pop("knot", None)
        self.__knot = knot
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        order  = kwargs.pop("order", 3)
        if order == None or order  <  2:
            return None
        self.__order = order
        tessellation  = kwargs.pop("tessellation", 0)
        self.__tessellation = tessellation
        weight  = kwargs.pop("weight", None)
        if weight == None or len(weight) <= 0 or min(weight)  <=  0:
            return None
        self.__weight = weight
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def controlPoint(self):
        return self.__controlPoint
    @controlPoint.setter
    def controlPoint(self, value = None):
        self.__controlPoint = [value]
    def setControlPoint(self, controlPoint = None):
        self.__controlPoint = [controlPoint]
        return self
    def addControlPoint(self, controlPoint = None):
        if self.__controlPoint == None:            self.__controlPoint =  []
        self.__controlPoint +=  [controlPoint]
        return self
    def removeControlPoint(self, controlPoint):
        self.__controlPoint = [x for x in self.__controlPoint if x not in controlPoint]
        return self.__controlPoint
    def getControlPoint(self, controlPoint = None):
        return self.__controlPoint
    def controlPoint_changed(self, controlPoint = None):
        return self.__controlPoint
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def tessellation(self):
        return self.__tessellation
    @tessellation.setter
    def tessellation(self, value = 0):
        self.__tessellation = [value]
    def setTessellation(self, tessellation = 0):
        self.__tessellation = [tessellation]
        return self
    def addTessellation(self, tessellation = 0):
        if self.__tessellation == None:            self.__tessellation =  []
        self.__tessellation +=  [tessellation]
        return self
    def removeTessellation(self, tessellation):
        self.__tessellation = [x for x in self.__tessellation if x not in tessellation]
        return self.__tessellation
    def getTessellation(self, tessellation = 0):
        return self.__tessellation
    def tessellation_changed(self, tessellation = 0):
        return self.__tessellation
    @property
    def weight(self):
        return self.__weight
    @weight.setter
    def weight(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <=  0:
            return None
        self.__weight = [value]
    def setWeight(self, weight = None):
        if weight == None or len(weight) <= 0 or min(weight)  <=  0:
            return None
        self.__weight = [weight]
        return self
    def addWeight(self, weight = None):
        if weight == None or len(weight) <= 0 or min(weight)  <=  0:
            return None
        if self.__weight == None:            self.__weight =  []
        self.__weight +=  [weight]
        return self
    def removeWeight(self, weight):
        self.__weight = [x for x in self.__weight if x not in weight]
        return self.__weight
    def getWeight(self, weight = None):
        return self.__weight
    def weight_changed(self, weight = None):
        return self.__weight
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<NurbsCurve'
        if self.__closed is not None:
            if isinstance(self.__closed, six.string_types):
                str += ' closed="'+self.__closed+'"'
            else:
                str += ' closed="'+self.__closed[0]+'"'
        if self.__knot is not None:
            if isinstance(self.__knot, six.string_types):
                str += ' knot="'+self.__knot+'"'
            else:
                str += ' knot="'+self.__knot[0]+'"'
        if self.__order is not None:
            if isinstance(self.__order, six.string_types):
                str += ' order="'+self.__order+'"'
            else:
                str += ' order="'+self.__order[0]+'"'
        if self.__tessellation is not None:
            if isinstance(self.__tessellation, six.string_types):
                str += ' tessellation="'+self.__tessellation+'"'
            else:
                str += ' tessellation="'+self.__tessellation[0]+'"'
        if self.__weight is not None:
            if isinstance(self.__weight, six.string_types):
                str += ' weight="'+self.__weight+'"'
            else:
                str += ' weight="'+self.__weight[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<controlPoint'
        if self.__controlPoint is not None:
           for s in self.__controlPoint:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__controlPoint is not None:
           for s in self.__controlPoint:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</controlPoint>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</NurbsCurve>'
        return str


class NurbsCurve2D(X3DNurbsControlCurveNode):
    def __init__(self, **kwargs):
        super(NurbsCurve2D, self).__init__(**kwargs)
        closed  = kwargs.pop("closed", False)
        self.__closed = closed
        controlPoint  = kwargs.pop("controlPoint", None)
        self.__controlPoint = controlPoint
        knot  = kwargs.pop("knot", None)
        self.__knot = knot
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        order  = kwargs.pop("order", 3)
        if order == None or order  <  2:
            return None
        self.__order = order
        tessellation  = kwargs.pop("tessellation", 0)
        self.__tessellation = tessellation
        weight  = kwargs.pop("weight", None)
        if weight == None or len(weight) <= 0 or min(weight)  <=  0:
            return None
        self.__weight = weight
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def controlPoint(self):
        return self.__controlPoint
    @controlPoint.setter
    def controlPoint(self, value = None):
        self.__controlPoint = [value]
    def setControlPoint(self, controlPoint = None):
        self.__controlPoint = [controlPoint]
        return self
    def addControlPoint(self, controlPoint = None):
        if self.__controlPoint == None:            self.__controlPoint =  []
        self.__controlPoint +=  [controlPoint]
        return self
    def removeControlPoint(self, controlPoint):
        self.__controlPoint = [x for x in self.__controlPoint if x not in controlPoint]
        return self.__controlPoint
    def getControlPoint(self, controlPoint = None):
        return self.__controlPoint
    def controlPoint_changed(self, controlPoint = None):
        return self.__controlPoint
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def tessellation(self):
        return self.__tessellation
    @tessellation.setter
    def tessellation(self, value = 0):
        self.__tessellation = [value]
    def setTessellation(self, tessellation = 0):
        self.__tessellation = [tessellation]
        return self
    def addTessellation(self, tessellation = 0):
        if self.__tessellation == None:            self.__tessellation =  []
        self.__tessellation +=  [tessellation]
        return self
    def removeTessellation(self, tessellation):
        self.__tessellation = [x for x in self.__tessellation if x not in tessellation]
        return self.__tessellation
    def getTessellation(self, tessellation = 0):
        return self.__tessellation
    def tessellation_changed(self, tessellation = 0):
        return self.__tessellation
    @property
    def weight(self):
        return self.__weight
    @weight.setter
    def weight(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <=  0:
            return None
        self.__weight = [value]
    def setWeight(self, weight = None):
        if weight == None or len(weight) <= 0 or min(weight)  <=  0:
            return None
        self.__weight = [weight]
        return self
    def addWeight(self, weight = None):
        if weight == None or len(weight) <= 0 or min(weight)  <=  0:
            return None
        if self.__weight == None:            self.__weight =  []
        self.__weight +=  [weight]
        return self
    def removeWeight(self, weight):
        self.__weight = [x for x in self.__weight if x not in weight]
        return self.__weight
    def getWeight(self, weight = None):
        return self.__weight
    def weight_changed(self, weight = None):
        return self.__weight
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<NurbsCurve2D'
        if self.__closed is not None:
            if isinstance(self.__closed, six.string_types):
                str += ' closed="'+self.__closed+'"'
            else:
                str += ' closed="'+self.__closed[0]+'"'
        if self.__controlPoint is not None:
            if isinstance(self.__controlPoint, six.string_types):
                str += ' controlPoint="'+self.__controlPoint+'"'
            else:
                str += ' controlPoint="'+self.__controlPoint[0]+'"'
        if self.__knot is not None:
            if isinstance(self.__knot, six.string_types):
                str += ' knot="'+self.__knot+'"'
            else:
                str += ' knot="'+self.__knot[0]+'"'
        if self.__order is not None:
            if isinstance(self.__order, six.string_types):
                str += ' order="'+self.__order+'"'
            else:
                str += ' order="'+self.__order[0]+'"'
        if self.__tessellation is not None:
            if isinstance(self.__tessellation, six.string_types):
                str += ' tessellation="'+self.__tessellation+'"'
            else:
                str += ' tessellation="'+self.__tessellation[0]+'"'
        if self.__weight is not None:
            if isinstance(self.__weight, six.string_types):
                str += ' weight="'+self.__weight+'"'
            else:
                str += ' weight="'+self.__weight[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</NurbsCurve2D>'
        return str


class NurbsOrientationInterpolator(X3DChildNode):
    def __init__(self, **kwargs):
        super(NurbsOrientationInterpolator, self).__init__(**kwargs)
        controlPoint  = kwargs.pop("controlPoint", None)
        self.__controlPoint = controlPoint
        knot  = kwargs.pop("knot", None)
        self.__knot = knot
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        order  = kwargs.pop("order", 3)
        if order == None or order  <  2:
            return None
        self.__order = order
        fraction  = kwargs.pop("fraction", None)
        self.__fraction = fraction
        value_changed  = kwargs.pop("value_changed", None)
        self.__value_changed = value_changed
        weight  = kwargs.pop("weight", None)
        self.__weight = weight
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def controlPoint(self):
        return self.__controlPoint
    @controlPoint.setter
    def controlPoint(self, value = None):
        self.__controlPoint = [value]
    def setControlPoint(self, controlPoint = None):
        self.__controlPoint = [controlPoint]
        return self
    def addControlPoint(self, controlPoint = None):
        if self.__controlPoint == None:            self.__controlPoint =  []
        self.__controlPoint +=  [controlPoint]
        return self
    def removeControlPoint(self, controlPoint):
        self.__controlPoint = [x for x in self.__controlPoint if x not in controlPoint]
        return self.__controlPoint
    def getControlPoint(self, controlPoint = None):
        return self.__controlPoint
    def controlPoint_changed(self, controlPoint = None):
        return self.__controlPoint
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def order(self):
        return self.__order
    @order.setter
    def order(self, value = 3):
        if value == None or value  <  2:
            return None
        self.__order = [value]
    def setOrder(self, order = 3):
        if order == None or order  <  2:
            return None
        self.__order = [order]
        return self
    def addOrder(self, order = 3):
        if order == None or order  <  2:
            return None
        if self.__order == None:            self.__order =  []
        self.__order +=  [order]
        return self
    def removeOrder(self, order):
        self.__order = [x for x in self.__order if x not in order]
        return self.__order
    def getOrder(self, order = 3):
        return self.__order
    def order_changed(self, order = 3):
        return self.__order
    @property
    def fraction(self):
        return self.__fraction
    @fraction.setter
    def fraction(self, value = None):
        self.__fraction = [value]
    def set_fraction(self, fraction = None):
        self.__fraction = [fraction]
        return self
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def weight(self):
        return self.__weight
    @weight.setter
    def weight(self, value = None):
        self.__weight = [value]
    def setWeight(self, weight = None):
        self.__weight = [weight]
        return self
    def addWeight(self, weight = None):
        if self.__weight == None:            self.__weight =  []
        self.__weight +=  [weight]
        return self
    def removeWeight(self, weight):
        self.__weight = [x for x in self.__weight if x not in weight]
        return self.__weight
    def getWeight(self, weight = None):
        return self.__weight
    def weight_changed(self, weight = None):
        return self.__weight
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<NurbsOrientationInterpolator'
        if self.__knot is not None:
            if isinstance(self.__knot, six.string_types):
                str += ' knot="'+self.__knot+'"'
            else:
                str += ' knot="'+self.__knot[0]+'"'
        if self.__order is not None:
            if isinstance(self.__order, six.string_types):
                str += ' order="'+self.__order+'"'
            else:
                str += ' order="'+self.__order[0]+'"'
        if self.__fraction is not None:
            if isinstance(self.__fraction, six.string_types):
                str += ' fraction="'+self.__fraction+'"'
            else:
                str += ' fraction="'+self.__fraction[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__weight is not None:
            if isinstance(self.__weight, six.string_types):
                str += ' weight="'+self.__weight+'"'
            else:
                str += ' weight="'+self.__weight[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<controlPoint'
        if self.__controlPoint is not None:
           for s in self.__controlPoint:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__controlPoint is not None:
           for s in self.__controlPoint:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</controlPoint>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</NurbsOrientationInterpolator>'
        return str


class NurbsPatchSurface(X3DNurbsSurfaceGeometryNode):
    def __init__(self, **kwargs):
        super(NurbsPatchSurface, self).__init__(**kwargs)
        controlPoint  = kwargs.pop("controlPoint", None)
        self.__controlPoint = controlPoint
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        solid  = kwargs.pop("solid", True)
        self.__solid = solid
        texCoord  = kwargs.pop("texCoord", None)
        self.__texCoord = texCoord
        uClosed  = kwargs.pop("uClosed", False)
        self.__uClosed = uClosed
        uDimension  = kwargs.pop("uDimension", 0)
        if uDimension == None or uDimension  <  0:
            return None
        self.__uDimension = uDimension
        uKnot  = kwargs.pop("uKnot", None)
        self.__uKnot = uKnot
        uOrder  = kwargs.pop("uOrder", 3)
        if uOrder == None or uOrder  <  2:
            return None
        self.__uOrder = uOrder
        uTessellation  = kwargs.pop("uTessellation", 0)
        self.__uTessellation = uTessellation
        vClosed  = kwargs.pop("vClosed", False)
        self.__vClosed = vClosed
        vDimension  = kwargs.pop("vDimension", 0)
        if vDimension == None or vDimension  <  0:
            return None
        self.__vDimension = vDimension
        vKnot  = kwargs.pop("vKnot", None)
        self.__vKnot = vKnot
        vOrder  = kwargs.pop("vOrder", 3)
        if vOrder == None or vOrder  <  2:
            return None
        self.__vOrder = vOrder
        vTessellation  = kwargs.pop("vTessellation", 0)
        self.__vTessellation = vTessellation
        weight  = kwargs.pop("weight", None)
        if weight == None or len(weight) <= 0 or min(weight)  <=  0:
            return None
        self.__weight = weight
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def controlPoint(self):
        return self.__controlPoint
    @controlPoint.setter
    def controlPoint(self, value = None):
        self.__controlPoint = [value]
    def setControlPoint(self, controlPoint = None):
        self.__controlPoint = [controlPoint]
        return self
    def addControlPoint(self, controlPoint = None):
        if self.__controlPoint == None:            self.__controlPoint =  []
        self.__controlPoint +=  [controlPoint]
        return self
    def removeControlPoint(self, controlPoint):
        self.__controlPoint = [x for x in self.__controlPoint if x not in controlPoint]
        return self.__controlPoint
    def getControlPoint(self, controlPoint = None):
        return self.__controlPoint
    def controlPoint_changed(self, controlPoint = None):
        return self.__controlPoint
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def texCoord(self):
        return self.__texCoord
    @texCoord.setter
    def texCoord(self, value = None):
        self.__texCoord = [value]
    def setTexCoord(self, texCoord = None):
        self.__texCoord = [texCoord]
        return self
    def addTexCoord(self, texCoord = None):
        if self.__texCoord == None:            self.__texCoord =  []
        self.__texCoord +=  [texCoord]
        return self
    def removeTexCoord(self, texCoord):
        self.__texCoord = [x for x in self.__texCoord if x not in texCoord]
        return self.__texCoord
    def getTexCoord(self, texCoord = None):
        return self.__texCoord
    def texCoord_changed(self, texCoord = None):
        return self.__texCoord
    @property
    def uTessellation(self):
        return self.__uTessellation
    @uTessellation.setter
    def uTessellation(self, value = 0):
        self.__uTessellation = [value]
    def setUTessellation(self, uTessellation = 0):
        self.__uTessellation = [uTessellation]
        return self
    def addUTessellation(self, uTessellation = 0):
        if self.__uTessellation == None:            self.__uTessellation =  []
        self.__uTessellation +=  [uTessellation]
        return self
    def removeUTessellation(self, uTessellation):
        self.__uTessellation = [x for x in self.__uTessellation if x not in uTessellation]
        return self.__uTessellation
    def getUTessellation(self, uTessellation = 0):
        return self.__uTessellation
    def uTessellation_changed(self, uTessellation = 0):
        return self.__uTessellation
    @property
    def vTessellation(self):
        return self.__vTessellation
    @vTessellation.setter
    def vTessellation(self, value = 0):
        self.__vTessellation = [value]
    def setVTessellation(self, vTessellation = 0):
        self.__vTessellation = [vTessellation]
        return self
    def addVTessellation(self, vTessellation = 0):
        if self.__vTessellation == None:            self.__vTessellation =  []
        self.__vTessellation +=  [vTessellation]
        return self
    def removeVTessellation(self, vTessellation):
        self.__vTessellation = [x for x in self.__vTessellation if x not in vTessellation]
        return self.__vTessellation
    def getVTessellation(self, vTessellation = 0):
        return self.__vTessellation
    def vTessellation_changed(self, vTessellation = 0):
        return self.__vTessellation
    @property
    def weight(self):
        return self.__weight
    @weight.setter
    def weight(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <=  0:
            return None
        self.__weight = [value]
    def setWeight(self, weight = None):
        if weight == None or len(weight) <= 0 or min(weight)  <=  0:
            return None
        self.__weight = [weight]
        return self
    def addWeight(self, weight = None):
        if weight == None or len(weight) <= 0 or min(weight)  <=  0:
            return None
        if self.__weight == None:            self.__weight =  []
        self.__weight +=  [weight]
        return self
    def removeWeight(self, weight):
        self.__weight = [x for x in self.__weight if x not in weight]
        return self.__weight
    def getWeight(self, weight = None):
        return self.__weight
    def weight_changed(self, weight = None):
        return self.__weight
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<NurbsPatchSurface'
        if self.__solid is not None:
            if isinstance(self.__solid, six.string_types):
                str += ' solid="'+self.__solid+'"'
            else:
                str += ' solid="'+self.__solid[0]+'"'
        if self.__uClosed is not None:
            if isinstance(self.__uClosed, six.string_types):
                str += ' uClosed="'+self.__uClosed+'"'
            else:
                str += ' uClosed="'+self.__uClosed[0]+'"'
        if self.__uDimension is not None:
            if isinstance(self.__uDimension, six.string_types):
                str += ' uDimension="'+self.__uDimension+'"'
            else:
                str += ' uDimension="'+self.__uDimension[0]+'"'
        if self.__uKnot is not None:
            if isinstance(self.__uKnot, six.string_types):
                str += ' uKnot="'+self.__uKnot+'"'
            else:
                str += ' uKnot="'+self.__uKnot[0]+'"'
        if self.__uOrder is not None:
            if isinstance(self.__uOrder, six.string_types):
                str += ' uOrder="'+self.__uOrder+'"'
            else:
                str += ' uOrder="'+self.__uOrder[0]+'"'
        if self.__uTessellation is not None:
            if isinstance(self.__uTessellation, six.string_types):
                str += ' uTessellation="'+self.__uTessellation+'"'
            else:
                str += ' uTessellation="'+self.__uTessellation[0]+'"'
        if self.__vClosed is not None:
            if isinstance(self.__vClosed, six.string_types):
                str += ' vClosed="'+self.__vClosed+'"'
            else:
                str += ' vClosed="'+self.__vClosed[0]+'"'
        if self.__vDimension is not None:
            if isinstance(self.__vDimension, six.string_types):
                str += ' vDimension="'+self.__vDimension+'"'
            else:
                str += ' vDimension="'+self.__vDimension[0]+'"'
        if self.__vKnot is not None:
            if isinstance(self.__vKnot, six.string_types):
                str += ' vKnot="'+self.__vKnot+'"'
            else:
                str += ' vKnot="'+self.__vKnot[0]+'"'
        if self.__vOrder is not None:
            if isinstance(self.__vOrder, six.string_types):
                str += ' vOrder="'+self.__vOrder+'"'
            else:
                str += ' vOrder="'+self.__vOrder[0]+'"'
        if self.__vTessellation is not None:
            if isinstance(self.__vTessellation, six.string_types):
                str += ' vTessellation="'+self.__vTessellation+'"'
            else:
                str += ' vTessellation="'+self.__vTessellation[0]+'"'
        if self.__weight is not None:
            if isinstance(self.__weight, six.string_types):
                str += ' weight="'+self.__weight+'"'
            else:
                str += ' weight="'+self.__weight[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<controlPoint'
        if self.__controlPoint is not None:
           for s in self.__controlPoint:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__controlPoint is not None:
           for s in self.__controlPoint:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</controlPoint>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<texCoord'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</texCoord>'
        str += '</NurbsPatchSurface>'
        return str


class NurbsPositionInterpolator(X3DChildNode):
    def __init__(self, **kwargs):
        super(NurbsPositionInterpolator, self).__init__(**kwargs)
        controlPoint  = kwargs.pop("controlPoint", None)
        self.__controlPoint = controlPoint
        knot  = kwargs.pop("knot", None)
        self.__knot = knot
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        order  = kwargs.pop("order", 3)
        if order == None or order  <  2:
            return None
        self.__order = order
        fraction  = kwargs.pop("fraction", None)
        self.__fraction = fraction
        value_changed  = kwargs.pop("value_changed", None)
        self.__value_changed = value_changed
        weight  = kwargs.pop("weight", None)
        self.__weight = weight
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def controlPoint(self):
        return self.__controlPoint
    @controlPoint.setter
    def controlPoint(self, value = None):
        self.__controlPoint = [value]
    def setControlPoint(self, controlPoint = None):
        self.__controlPoint = [controlPoint]
        return self
    def addControlPoint(self, controlPoint = None):
        if self.__controlPoint == None:            self.__controlPoint =  []
        self.__controlPoint +=  [controlPoint]
        return self
    def removeControlPoint(self, controlPoint):
        self.__controlPoint = [x for x in self.__controlPoint if x not in controlPoint]
        return self.__controlPoint
    def getControlPoint(self, controlPoint = None):
        return self.__controlPoint
    def controlPoint_changed(self, controlPoint = None):
        return self.__controlPoint
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def order(self):
        return self.__order
    @order.setter
    def order(self, value = 3):
        if value == None or value  <  2:
            return None
        self.__order = [value]
    def setOrder(self, order = 3):
        if order == None or order  <  2:
            return None
        self.__order = [order]
        return self
    def addOrder(self, order = 3):
        if order == None or order  <  2:
            return None
        if self.__order == None:            self.__order =  []
        self.__order +=  [order]
        return self
    def removeOrder(self, order):
        self.__order = [x for x in self.__order if x not in order]
        return self.__order
    def getOrder(self, order = 3):
        return self.__order
    def order_changed(self, order = 3):
        return self.__order
    @property
    def fraction(self):
        return self.__fraction
    @fraction.setter
    def fraction(self, value = None):
        self.__fraction = [value]
    def set_fraction(self, fraction = None):
        self.__fraction = [fraction]
        return self
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def weight(self):
        return self.__weight
    @weight.setter
    def weight(self, value = None):
        self.__weight = [value]
    def setWeight(self, weight = None):
        self.__weight = [weight]
        return self
    def addWeight(self, weight = None):
        if self.__weight == None:            self.__weight =  []
        self.__weight +=  [weight]
        return self
    def removeWeight(self, weight):
        self.__weight = [x for x in self.__weight if x not in weight]
        return self.__weight
    def getWeight(self, weight = None):
        return self.__weight
    def weight_changed(self, weight = None):
        return self.__weight
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<NurbsPositionInterpolator'
        if self.__knot is not None:
            if isinstance(self.__knot, six.string_types):
                str += ' knot="'+self.__knot+'"'
            else:
                str += ' knot="'+self.__knot[0]+'"'
        if self.__order is not None:
            if isinstance(self.__order, six.string_types):
                str += ' order="'+self.__order+'"'
            else:
                str += ' order="'+self.__order[0]+'"'
        if self.__fraction is not None:
            if isinstance(self.__fraction, six.string_types):
                str += ' fraction="'+self.__fraction+'"'
            else:
                str += ' fraction="'+self.__fraction[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__weight is not None:
            if isinstance(self.__weight, six.string_types):
                str += ' weight="'+self.__weight+'"'
            else:
                str += ' weight="'+self.__weight[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<controlPoint'
        if self.__controlPoint is not None:
           for s in self.__controlPoint:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__controlPoint is not None:
           for s in self.__controlPoint:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</controlPoint>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</NurbsPositionInterpolator>'
        return str


class NurbsSet(X3DBoundedObject, X3DChildNode):
    def __init__(self, **kwargs):
        super(NurbsSet, self).__init__(**kwargs)
        Geometry  = kwargs.pop("Geometry", None)
        self.__Geometry = Geometry
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        geometry  = kwargs.pop("geometry", None)
        self.__geometry = geometry
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        Geometry  = kwargs.pop("Geometry", None)
        self.__Geometry = Geometry
        tessellationScale  = kwargs.pop("tessellationScale", 1.0)
        if tessellationScale == None or tessellationScale  <=  0:
            return None
        self.__tessellationScale = tessellationScale
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def Geometry(self):
        return self.__Geometry
    @Geometry.setter
    def Geometry(self, value = None):
        self.__Geometry = [value]
    def addGeometry(self, Geometry = None):
        if self.__Geometry == None:            self.__Geometry =  []
        self.__Geometry +=  [Geometry]
        return self
    @property
    def geometry(self):
        return self.__geometry
    @geometry.setter
    def geometry(self, value = None):
        self.__geometry = [value]
    def setGeometry(self, geometry = None):
        self.__geometry = [geometry]
        return self
    def addGeometry(self, geometry = None):
        if self.__geometry == None:            self.__geometry =  []
        self.__geometry +=  [geometry]
        return self
    def removeGeometry(self, geometry):
        self.__geometry = [x for x in self.__geometry if x not in geometry]
        return self.__geometry
    def getGeometry(self, geometry = None):
        return self.__geometry
    def geometry_changed(self, geometry = None):
        return self.__geometry
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def Geometry(self):
        return self.__Geometry
    @Geometry.setter
    def Geometry(self, value = None):
        self.__Geometry = [value]
    @property
    def tessellationScale(self):
        return self.__tessellationScale
    @tessellationScale.setter
    def tessellationScale(self, value = 1.0):
        if value == None or value  <=  0:
            return None
        self.__tessellationScale = [value]
    def setTessellationScale(self, tessellationScale = 1.0):
        if tessellationScale == None or tessellationScale  <=  0:
            return None
        self.__tessellationScale = [tessellationScale]
        return self
    def addTessellationScale(self, tessellationScale = 1.0):
        if tessellationScale == None or tessellationScale  <=  0:
            return None
        if self.__tessellationScale == None:            self.__tessellationScale =  []
        self.__tessellationScale +=  [tessellationScale]
        return self
    def removeTessellationScale(self, tessellationScale):
        self.__tessellationScale = [x for x in self.__tessellationScale if x not in tessellationScale]
        return self.__tessellationScale
    def getTessellationScale(self, tessellationScale = 1.0):
        return self.__tessellationScale
    def tessellationScale_changed(self, tessellationScale = 1.0):
        return self.__tessellationScale
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<NurbsSet'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__tessellationScale is not None:
            if isinstance(self.__tessellationScale, six.string_types):
                str += ' tessellationScale="'+self.__tessellationScale+'"'
            else:
                str += ' tessellationScale="'+self.__tessellationScale[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<Geometry'
        if self.__Geometry is not None:
           for s in self.__Geometry:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__Geometry is not None:
           for s in self.__Geometry:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Geometry>'
        str += '<geometry'
        if self.__geometry is not None:
           for s in self.__geometry:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__geometry is not None:
           for s in self.__geometry:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</geometry>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<Geometry'
        if self.__Geometry is not None:
           for s in self.__Geometry:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__Geometry is not None:
           for s in self.__Geometry:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Geometry>'
        str += '</NurbsSet>'
        return str


class NurbsSurfaceInterpolator(X3DChildNode):
    def __init__(self, **kwargs):
        super(NurbsSurfaceInterpolator, self).__init__(**kwargs)
        controlPoint  = kwargs.pop("controlPoint", None)
        self.__controlPoint = controlPoint
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        normal_changed  = kwargs.pop("normal_changed", None)
        self.__normal_changed = normal_changed
        position_changed  = kwargs.pop("position_changed", None)
        self.__position_changed = position_changed
        fraction  = kwargs.pop("fraction", None)
        self.__fraction = fraction
        uDimension  = kwargs.pop("uDimension", 0)
        if uDimension == None or uDimension  <  0:
            return None
        self.__uDimension = uDimension
        uKnot  = kwargs.pop("uKnot", None)
        self.__uKnot = uKnot
        uOrder  = kwargs.pop("uOrder", 3)
        if uOrder == None or uOrder  <  2:
            return None
        self.__uOrder = uOrder
        vDimension  = kwargs.pop("vDimension", 0)
        if vDimension == None or vDimension  <  0:
            return None
        self.__vDimension = vDimension
        vKnot  = kwargs.pop("vKnot", None)
        self.__vKnot = vKnot
        vOrder  = kwargs.pop("vOrder", 3)
        if vOrder == None or vOrder  <  2:
            return None
        self.__vOrder = vOrder
        weight  = kwargs.pop("weight", None)
        self.__weight = weight
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def controlPoint(self):
        return self.__controlPoint
    @controlPoint.setter
    def controlPoint(self, value = None):
        self.__controlPoint = [value]
    def setControlPoint(self, controlPoint = None):
        self.__controlPoint = [controlPoint]
        return self
    def addControlPoint(self, controlPoint = None):
        if self.__controlPoint == None:            self.__controlPoint =  []
        self.__controlPoint +=  [controlPoint]
        return self
    def removeControlPoint(self, controlPoint):
        self.__controlPoint = [x for x in self.__controlPoint if x not in controlPoint]
        return self.__controlPoint
    def getControlPoint(self, controlPoint = None):
        return self.__controlPoint
    def controlPoint_changed(self, controlPoint = None):
        return self.__controlPoint
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    def removenormal_changed(self, normal_changed):
        self.__normal_changed = [x for x in self.__normal_changed if x not in normal_changed]
        return self.__normal_changed
    def getnormal_changed(self, normal_changed = None):
        return self.__normal_changed
    def normal_changed_changed(self, normal_changed = None):
        return self.__normal_changed
    def removeposition_changed(self, position_changed):
        self.__position_changed = [x for x in self.__position_changed if x not in position_changed]
        return self.__position_changed
    def getposition_changed(self, position_changed = None):
        return self.__position_changed
    def position_changed_changed(self, position_changed = None):
        return self.__position_changed
    @property
    def fraction(self):
        return self.__fraction
    @fraction.setter
    def fraction(self, value = None):
        self.__fraction = [value]
    def set_fraction(self, fraction = None):
        self.__fraction = [fraction]
        return self
    @property
    def weight(self):
        return self.__weight
    @weight.setter
    def weight(self, value = None):
        self.__weight = [value]
    def setWeight(self, weight = None):
        self.__weight = [weight]
        return self
    def addWeight(self, weight = None):
        if self.__weight == None:            self.__weight =  []
        self.__weight +=  [weight]
        return self
    def removeWeight(self, weight):
        self.__weight = [x for x in self.__weight if x not in weight]
        return self.__weight
    def getWeight(self, weight = None):
        return self.__weight
    def weight_changed(self, weight = None):
        return self.__weight
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<NurbsSurfaceInterpolator'
        if self.__normal_changed is not None:
            if isinstance(self.__normal_changed, six.string_types):
                str += ' normal_changed="'+self.__normal_changed+'"'
            else:
                str += ' normal_changed="'+self.__normal_changed[0]+'"'
        if self.__position_changed is not None:
            if isinstance(self.__position_changed, six.string_types):
                str += ' position_changed="'+self.__position_changed+'"'
            else:
                str += ' position_changed="'+self.__position_changed[0]+'"'
        if self.__fraction is not None:
            if isinstance(self.__fraction, six.string_types):
                str += ' fraction="'+self.__fraction+'"'
            else:
                str += ' fraction="'+self.__fraction[0]+'"'
        if self.__uDimension is not None:
            if isinstance(self.__uDimension, six.string_types):
                str += ' uDimension="'+self.__uDimension+'"'
            else:
                str += ' uDimension="'+self.__uDimension[0]+'"'
        if self.__uKnot is not None:
            if isinstance(self.__uKnot, six.string_types):
                str += ' uKnot="'+self.__uKnot+'"'
            else:
                str += ' uKnot="'+self.__uKnot[0]+'"'
        if self.__uOrder is not None:
            if isinstance(self.__uOrder, six.string_types):
                str += ' uOrder="'+self.__uOrder+'"'
            else:
                str += ' uOrder="'+self.__uOrder[0]+'"'
        if self.__vDimension is not None:
            if isinstance(self.__vDimension, six.string_types):
                str += ' vDimension="'+self.__vDimension+'"'
            else:
                str += ' vDimension="'+self.__vDimension[0]+'"'
        if self.__vKnot is not None:
            if isinstance(self.__vKnot, six.string_types):
                str += ' vKnot="'+self.__vKnot+'"'
            else:
                str += ' vKnot="'+self.__vKnot[0]+'"'
        if self.__vOrder is not None:
            if isinstance(self.__vOrder, six.string_types):
                str += ' vOrder="'+self.__vOrder+'"'
            else:
                str += ' vOrder="'+self.__vOrder[0]+'"'
        if self.__weight is not None:
            if isinstance(self.__weight, six.string_types):
                str += ' weight="'+self.__weight+'"'
            else:
                str += ' weight="'+self.__weight[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<controlPoint'
        if self.__controlPoint is not None:
           for s in self.__controlPoint:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__controlPoint is not None:
           for s in self.__controlPoint:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</controlPoint>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</NurbsSurfaceInterpolator>'
        return str


class NurbsSweptSurface(X3DParametricGeometryNode):
    def __init__(self, **kwargs):
        super(NurbsSweptSurface, self).__init__(**kwargs)
        ccw  = kwargs.pop("ccw", True)
        self.__ccw = ccw
        crossSectionCurve  = kwargs.pop("crossSectionCurve", None)
        self.__crossSectionCurve = crossSectionCurve
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        solid  = kwargs.pop("solid", True)
        self.__solid = solid
        trajectoryCurve  = kwargs.pop("trajectoryCurve", None)
        self.__trajectoryCurve = trajectoryCurve
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def crossSectionCurve(self):
        return self.__crossSectionCurve
    @crossSectionCurve.setter
    def crossSectionCurve(self, value = None):
        self.__crossSectionCurve = [value]
    def setCrossSectionCurve(self, crossSectionCurve = None):
        self.__crossSectionCurve = [crossSectionCurve]
        return self
    def addCrossSectionCurve(self, crossSectionCurve = None):
        if self.__crossSectionCurve == None:            self.__crossSectionCurve =  []
        self.__crossSectionCurve +=  [crossSectionCurve]
        return self
    def removeCrossSectionCurve(self, crossSectionCurve):
        self.__crossSectionCurve = [x for x in self.__crossSectionCurve if x not in crossSectionCurve]
        return self.__crossSectionCurve
    def getCrossSectionCurve(self, crossSectionCurve = None):
        return self.__crossSectionCurve
    def crossSectionCurve_changed(self, crossSectionCurve = None):
        return self.__crossSectionCurve
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def trajectoryCurve(self):
        return self.__trajectoryCurve
    @trajectoryCurve.setter
    def trajectoryCurve(self, value = None):
        self.__trajectoryCurve = [value]
    def setTrajectoryCurve(self, trajectoryCurve = None):
        self.__trajectoryCurve = [trajectoryCurve]
        return self
    def addTrajectoryCurve(self, trajectoryCurve = None):
        if self.__trajectoryCurve == None:            self.__trajectoryCurve =  []
        self.__trajectoryCurve +=  [trajectoryCurve]
        return self
    def removeTrajectoryCurve(self, trajectoryCurve):
        self.__trajectoryCurve = [x for x in self.__trajectoryCurve if x not in trajectoryCurve]
        return self.__trajectoryCurve
    def getTrajectoryCurve(self, trajectoryCurve = None):
        return self.__trajectoryCurve
    def trajectoryCurve_changed(self, trajectoryCurve = None):
        return self.__trajectoryCurve
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<NurbsSweptSurface'
        if self.__ccw is not None:
            if isinstance(self.__ccw, six.string_types):
                str += ' ccw="'+self.__ccw+'"'
            else:
                str += ' ccw="'+self.__ccw[0]+'"'
        if self.__solid is not None:
            if isinstance(self.__solid, six.string_types):
                str += ' solid="'+self.__solid+'"'
            else:
                str += ' solid="'+self.__solid[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<crossSectionCurve'
        if self.__crossSectionCurve is not None:
           for s in self.__crossSectionCurve:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__crossSectionCurve is not None:
           for s in self.__crossSectionCurve:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</crossSectionCurve>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<trajectoryCurve'
        if self.__trajectoryCurve is not None:
           for s in self.__trajectoryCurve:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__trajectoryCurve is not None:
           for s in self.__trajectoryCurve:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</trajectoryCurve>'
        str += '</NurbsSweptSurface>'
        return str


class NurbsSwungSurface(X3DParametricGeometryNode):
    def __init__(self, **kwargs):
        super(NurbsSwungSurface, self).__init__(**kwargs)
        ccw  = kwargs.pop("ccw", True)
        self.__ccw = ccw
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        profileCurve  = kwargs.pop("profileCurve", None)
        self.__profileCurve = profileCurve
        solid  = kwargs.pop("solid", True)
        self.__solid = solid
        trajectoryCurve  = kwargs.pop("trajectoryCurve", None)
        self.__trajectoryCurve = trajectoryCurve
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def profileCurve(self):
        return self.__profileCurve
    @profileCurve.setter
    def profileCurve(self, value = None):
        self.__profileCurve = [value]
    def setProfileCurve(self, profileCurve = None):
        self.__profileCurve = [profileCurve]
        return self
    def addProfileCurve(self, profileCurve = None):
        if self.__profileCurve == None:            self.__profileCurve =  []
        self.__profileCurve +=  [profileCurve]
        return self
    def removeProfileCurve(self, profileCurve):
        self.__profileCurve = [x for x in self.__profileCurve if x not in profileCurve]
        return self.__profileCurve
    def getProfileCurve(self, profileCurve = None):
        return self.__profileCurve
    def profileCurve_changed(self, profileCurve = None):
        return self.__profileCurve
    @property
    def trajectoryCurve(self):
        return self.__trajectoryCurve
    @trajectoryCurve.setter
    def trajectoryCurve(self, value = None):
        self.__trajectoryCurve = [value]
    def setTrajectoryCurve(self, trajectoryCurve = None):
        self.__trajectoryCurve = [trajectoryCurve]
        return self
    def addTrajectoryCurve(self, trajectoryCurve = None):
        if self.__trajectoryCurve == None:            self.__trajectoryCurve =  []
        self.__trajectoryCurve +=  [trajectoryCurve]
        return self
    def removeTrajectoryCurve(self, trajectoryCurve):
        self.__trajectoryCurve = [x for x in self.__trajectoryCurve if x not in trajectoryCurve]
        return self.__trajectoryCurve
    def getTrajectoryCurve(self, trajectoryCurve = None):
        return self.__trajectoryCurve
    def trajectoryCurve_changed(self, trajectoryCurve = None):
        return self.__trajectoryCurve
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<NurbsSwungSurface'
        if self.__ccw is not None:
            if isinstance(self.__ccw, six.string_types):
                str += ' ccw="'+self.__ccw+'"'
            else:
                str += ' ccw="'+self.__ccw[0]+'"'
        if self.__solid is not None:
            if isinstance(self.__solid, six.string_types):
                str += ' solid="'+self.__solid+'"'
            else:
                str += ' solid="'+self.__solid[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<profileCurve'
        if self.__profileCurve is not None:
           for s in self.__profileCurve:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__profileCurve is not None:
           for s in self.__profileCurve:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</profileCurve>'
        str += '<trajectoryCurve'
        if self.__trajectoryCurve is not None:
           for s in self.__trajectoryCurve:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__trajectoryCurve is not None:
           for s in self.__trajectoryCurve:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</trajectoryCurve>'
        str += '</NurbsSwungSurface>'
        return str


class NurbsTextureCoordinate(X3DNode):
    def __init__(self, **kwargs):
        super(NurbsTextureCoordinate, self).__init__(**kwargs)
        controlPoint  = kwargs.pop("controlPoint", None)
        self.__controlPoint = controlPoint
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        uDimension  = kwargs.pop("uDimension", 0)
        if uDimension == None or uDimension  <  0:
            return None
        self.__uDimension = uDimension
        uKnot  = kwargs.pop("uKnot", None)
        self.__uKnot = uKnot
        uOrder  = kwargs.pop("uOrder", 3)
        if uOrder == None or uOrder  <  2:
            return None
        self.__uOrder = uOrder
        vDimension  = kwargs.pop("vDimension", 0)
        if vDimension == None or vDimension  <  0:
            return None
        self.__vDimension = vDimension
        vKnot  = kwargs.pop("vKnot", None)
        self.__vKnot = vKnot
        vOrder  = kwargs.pop("vOrder", 3)
        if vOrder == None or vOrder  <  2:
            return None
        self.__vOrder = vOrder
        weight  = kwargs.pop("weight", None)
        if weight == None or len(weight) <= 0 or min(weight)  <=  0:
            return None
        self.__weight = weight
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def controlPoint(self):
        return self.__controlPoint
    @controlPoint.setter
    def controlPoint(self, value = None):
        self.__controlPoint = [value]
    def setControlPoint(self, controlPoint = None):
        self.__controlPoint = [controlPoint]
        return self
    def addControlPoint(self, controlPoint = None):
        if self.__controlPoint == None:            self.__controlPoint =  []
        self.__controlPoint +=  [controlPoint]
        return self
    def removeControlPoint(self, controlPoint):
        self.__controlPoint = [x for x in self.__controlPoint if x not in controlPoint]
        return self.__controlPoint
    def getControlPoint(self, controlPoint = None):
        return self.__controlPoint
    def controlPoint_changed(self, controlPoint = None):
        return self.__controlPoint
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def weight(self):
        return self.__weight
    @weight.setter
    def weight(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <=  0:
            return None
        self.__weight = [value]
    def setWeight(self, weight = None):
        if weight == None or len(weight) <= 0 or min(weight)  <=  0:
            return None
        self.__weight = [weight]
        return self
    def addWeight(self, weight = None):
        if weight == None or len(weight) <= 0 or min(weight)  <=  0:
            return None
        if self.__weight == None:            self.__weight =  []
        self.__weight +=  [weight]
        return self
    def removeWeight(self, weight):
        self.__weight = [x for x in self.__weight if x not in weight]
        return self.__weight
    def getWeight(self, weight = None):
        return self.__weight
    def weight_changed(self, weight = None):
        return self.__weight
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<NurbsTextureCoordinate'
        if self.__controlPoint is not None:
            if isinstance(self.__controlPoint, six.string_types):
                str += ' controlPoint="'+self.__controlPoint+'"'
            else:
                str += ' controlPoint="'+self.__controlPoint[0]+'"'
        if self.__uDimension is not None:
            if isinstance(self.__uDimension, six.string_types):
                str += ' uDimension="'+self.__uDimension+'"'
            else:
                str += ' uDimension="'+self.__uDimension[0]+'"'
        if self.__uKnot is not None:
            if isinstance(self.__uKnot, six.string_types):
                str += ' uKnot="'+self.__uKnot+'"'
            else:
                str += ' uKnot="'+self.__uKnot[0]+'"'
        if self.__uOrder is not None:
            if isinstance(self.__uOrder, six.string_types):
                str += ' uOrder="'+self.__uOrder+'"'
            else:
                str += ' uOrder="'+self.__uOrder[0]+'"'
        if self.__vDimension is not None:
            if isinstance(self.__vDimension, six.string_types):
                str += ' vDimension="'+self.__vDimension+'"'
            else:
                str += ' vDimension="'+self.__vDimension[0]+'"'
        if self.__vKnot is not None:
            if isinstance(self.__vKnot, six.string_types):
                str += ' vKnot="'+self.__vKnot+'"'
            else:
                str += ' vKnot="'+self.__vKnot[0]+'"'
        if self.__vOrder is not None:
            if isinstance(self.__vOrder, six.string_types):
                str += ' vOrder="'+self.__vOrder+'"'
            else:
                str += ' vOrder="'+self.__vOrder[0]+'"'
        if self.__weight is not None:
            if isinstance(self.__weight, six.string_types):
                str += ' weight="'+self.__weight+'"'
            else:
                str += ' weight="'+self.__weight[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</NurbsTextureCoordinate>'
        return str


class NurbsTrimmedSurface(X3DNurbsSurfaceGeometryNode):
    def __init__(self, **kwargs):
        super(NurbsTrimmedSurface, self).__init__(**kwargs)
        TrimmingContour  = kwargs.pop("TrimmingContour", None)
        self.__TrimmingContour = TrimmingContour
        controlPoint  = kwargs.pop("controlPoint", None)
        self.__controlPoint = controlPoint
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        TrimmingContour  = kwargs.pop("TrimmingContour", None)
        self.__TrimmingContour = TrimmingContour
        solid  = kwargs.pop("solid", True)
        self.__solid = solid
        texCoord  = kwargs.pop("texCoord", None)
        self.__texCoord = texCoord
        trimmingContour  = kwargs.pop("trimmingContour", None)
        self.__trimmingContour = trimmingContour
        uClosed  = kwargs.pop("uClosed", False)
        self.__uClosed = uClosed
        uDimension  = kwargs.pop("uDimension", 0)
        if uDimension == None or uDimension  <  0:
            return None
        self.__uDimension = uDimension
        uKnot  = kwargs.pop("uKnot", None)
        self.__uKnot = uKnot
        uOrder  = kwargs.pop("uOrder", 3)
        if uOrder == None or uOrder  <  2:
            return None
        self.__uOrder = uOrder
        uTessellation  = kwargs.pop("uTessellation", 0)
        self.__uTessellation = uTessellation
        vClosed  = kwargs.pop("vClosed", False)
        self.__vClosed = vClosed
        vDimension  = kwargs.pop("vDimension", 0)
        if vDimension == None or vDimension  <  0:
            return None
        self.__vDimension = vDimension
        vKnot  = kwargs.pop("vKnot", None)
        self.__vKnot = vKnot
        vOrder  = kwargs.pop("vOrder", 3)
        if vOrder == None or vOrder  <  2:
            return None
        self.__vOrder = vOrder
        vTessellation  = kwargs.pop("vTessellation", 0)
        self.__vTessellation = vTessellation
        weight  = kwargs.pop("weight", None)
        if weight == None or len(weight) <= 0 or min(weight)  <=  0:
            return None
        self.__weight = weight
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def TrimmingContour(self):
        return self.__TrimmingContour
    @TrimmingContour.setter
    def TrimmingContour(self, value = None):
        self.__TrimmingContour = [value]
    def addTrimmingContour(self, TrimmingContour = None):
        if self.__TrimmingContour == None:            self.__TrimmingContour =  []
        self.__TrimmingContour +=  [TrimmingContour]
        return self
    @property
    def controlPoint(self):
        return self.__controlPoint
    @controlPoint.setter
    def controlPoint(self, value = None):
        self.__controlPoint = [value]
    def setControlPoint(self, controlPoint = None):
        self.__controlPoint = [controlPoint]
        return self
    def addControlPoint(self, controlPoint = None):
        if self.__controlPoint == None:            self.__controlPoint =  []
        self.__controlPoint +=  [controlPoint]
        return self
    def removeControlPoint(self, controlPoint):
        self.__controlPoint = [x for x in self.__controlPoint if x not in controlPoint]
        return self.__controlPoint
    def getControlPoint(self, controlPoint = None):
        return self.__controlPoint
    def controlPoint_changed(self, controlPoint = None):
        return self.__controlPoint
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def TrimmingContour(self):
        return self.__TrimmingContour
    @TrimmingContour.setter
    def TrimmingContour(self, value = None):
        self.__TrimmingContour = [value]
    @property
    def texCoord(self):
        return self.__texCoord
    @texCoord.setter
    def texCoord(self, value = None):
        self.__texCoord = [value]
    def setTexCoord(self, texCoord = None):
        self.__texCoord = [texCoord]
        return self
    def addTexCoord(self, texCoord = None):
        if self.__texCoord == None:            self.__texCoord =  []
        self.__texCoord +=  [texCoord]
        return self
    def removeTexCoord(self, texCoord):
        self.__texCoord = [x for x in self.__texCoord if x not in texCoord]
        return self.__texCoord
    def getTexCoord(self, texCoord = None):
        return self.__texCoord
    def texCoord_changed(self, texCoord = None):
        return self.__texCoord
    @property
    def trimmingContour(self):
        return self.__trimmingContour
    @trimmingContour.setter
    def trimmingContour(self, value = None):
        self.__trimmingContour = [value]
    def setTrimmingContour(self, trimmingContour = None):
        self.__trimmingContour = [trimmingContour]
        return self
    def addTrimmingContour(self, trimmingContour = None):
        if self.__trimmingContour == None:            self.__trimmingContour =  []
        self.__trimmingContour +=  [trimmingContour]
        return self
    def removeTrimmingContour(self, trimmingContour):
        self.__trimmingContour = [x for x in self.__trimmingContour if x not in trimmingContour]
        return self.__trimmingContour
    def getTrimmingContour(self, trimmingContour = None):
        return self.__trimmingContour
    def trimmingContour_changed(self, trimmingContour = None):
        return self.__trimmingContour
    @property
    def uTessellation(self):
        return self.__uTessellation
    @uTessellation.setter
    def uTessellation(self, value = 0):
        self.__uTessellation = [value]
    def setUTessellation(self, uTessellation = 0):
        self.__uTessellation = [uTessellation]
        return self
    def addUTessellation(self, uTessellation = 0):
        if self.__uTessellation == None:            self.__uTessellation =  []
        self.__uTessellation +=  [uTessellation]
        return self
    def removeUTessellation(self, uTessellation):
        self.__uTessellation = [x for x in self.__uTessellation if x not in uTessellation]
        return self.__uTessellation
    def getUTessellation(self, uTessellation = 0):
        return self.__uTessellation
    def uTessellation_changed(self, uTessellation = 0):
        return self.__uTessellation
    @property
    def vTessellation(self):
        return self.__vTessellation
    @vTessellation.setter
    def vTessellation(self, value = 0):
        self.__vTessellation = [value]
    def setVTessellation(self, vTessellation = 0):
        self.__vTessellation = [vTessellation]
        return self
    def addVTessellation(self, vTessellation = 0):
        if self.__vTessellation == None:            self.__vTessellation =  []
        self.__vTessellation +=  [vTessellation]
        return self
    def removeVTessellation(self, vTessellation):
        self.__vTessellation = [x for x in self.__vTessellation if x not in vTessellation]
        return self.__vTessellation
    def getVTessellation(self, vTessellation = 0):
        return self.__vTessellation
    def vTessellation_changed(self, vTessellation = 0):
        return self.__vTessellation
    @property
    def weight(self):
        return self.__weight
    @weight.setter
    def weight(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <=  0:
            return None
        self.__weight = [value]
    def setWeight(self, weight = None):
        if weight == None or len(weight) <= 0 or min(weight)  <=  0:
            return None
        self.__weight = [weight]
        return self
    def addWeight(self, weight = None):
        if weight == None or len(weight) <= 0 or min(weight)  <=  0:
            return None
        if self.__weight == None:            self.__weight =  []
        self.__weight +=  [weight]
        return self
    def removeWeight(self, weight):
        self.__weight = [x for x in self.__weight if x not in weight]
        return self.__weight
    def getWeight(self, weight = None):
        return self.__weight
    def weight_changed(self, weight = None):
        return self.__weight
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<NurbsTrimmedSurface'
        if self.__solid is not None:
            if isinstance(self.__solid, six.string_types):
                str += ' solid="'+self.__solid+'"'
            else:
                str += ' solid="'+self.__solid[0]+'"'
        if self.__uClosed is not None:
            if isinstance(self.__uClosed, six.string_types):
                str += ' uClosed="'+self.__uClosed+'"'
            else:
                str += ' uClosed="'+self.__uClosed[0]+'"'
        if self.__uDimension is not None:
            if isinstance(self.__uDimension, six.string_types):
                str += ' uDimension="'+self.__uDimension+'"'
            else:
                str += ' uDimension="'+self.__uDimension[0]+'"'
        if self.__uKnot is not None:
            if isinstance(self.__uKnot, six.string_types):
                str += ' uKnot="'+self.__uKnot+'"'
            else:
                str += ' uKnot="'+self.__uKnot[0]+'"'
        if self.__uOrder is not None:
            if isinstance(self.__uOrder, six.string_types):
                str += ' uOrder="'+self.__uOrder+'"'
            else:
                str += ' uOrder="'+self.__uOrder[0]+'"'
        if self.__uTessellation is not None:
            if isinstance(self.__uTessellation, six.string_types):
                str += ' uTessellation="'+self.__uTessellation+'"'
            else:
                str += ' uTessellation="'+self.__uTessellation[0]+'"'
        if self.__vClosed is not None:
            if isinstance(self.__vClosed, six.string_types):
                str += ' vClosed="'+self.__vClosed+'"'
            else:
                str += ' vClosed="'+self.__vClosed[0]+'"'
        if self.__vDimension is not None:
            if isinstance(self.__vDimension, six.string_types):
                str += ' vDimension="'+self.__vDimension+'"'
            else:
                str += ' vDimension="'+self.__vDimension[0]+'"'
        if self.__vKnot is not None:
            if isinstance(self.__vKnot, six.string_types):
                str += ' vKnot="'+self.__vKnot+'"'
            else:
                str += ' vKnot="'+self.__vKnot[0]+'"'
        if self.__vOrder is not None:
            if isinstance(self.__vOrder, six.string_types):
                str += ' vOrder="'+self.__vOrder+'"'
            else:
                str += ' vOrder="'+self.__vOrder[0]+'"'
        if self.__vTessellation is not None:
            if isinstance(self.__vTessellation, six.string_types):
                str += ' vTessellation="'+self.__vTessellation+'"'
            else:
                str += ' vTessellation="'+self.__vTessellation[0]+'"'
        if self.__weight is not None:
            if isinstance(self.__weight, six.string_types):
                str += ' weight="'+self.__weight+'"'
            else:
                str += ' weight="'+self.__weight[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<TrimmingContour'
        if self.__TrimmingContour is not None:
           for s in self.__TrimmingContour:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__TrimmingContour is not None:
           for s in self.__TrimmingContour:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</TrimmingContour>'
        str += '<controlPoint'
        if self.__controlPoint is not None:
           for s in self.__controlPoint:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__controlPoint is not None:
           for s in self.__controlPoint:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</controlPoint>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<TrimmingContour'
        if self.__TrimmingContour is not None:
           for s in self.__TrimmingContour:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__TrimmingContour is not None:
           for s in self.__TrimmingContour:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</TrimmingContour>'
        str += '<texCoord'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</texCoord>'
        str += '<trimmingContour'
        if self.__trimmingContour is not None:
           for s in self.__trimmingContour:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__trimmingContour is not None:
           for s in self.__trimmingContour:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</trimmingContour>'
        str += '</NurbsTrimmedSurface>'
        return str


class OpacityMapVolumeStyle(X3DComposableVolumeRenderStyleNode):
    def __init__(self, **kwargs):
        super(OpacityMapVolumeStyle, self).__init__(**kwargs)
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        transferFunction  = kwargs.pop("transferFunction", None)
        self.__transferFunction = transferFunction
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def transferFunction(self):
        return self.__transferFunction
    @transferFunction.setter
    def transferFunction(self, value = None):
        self.__transferFunction = [value]
    def setTransferFunction(self, transferFunction = None):
        self.__transferFunction = [transferFunction]
        return self
    def addTransferFunction(self, transferFunction = None):
        if self.__transferFunction == None:            self.__transferFunction =  []
        self.__transferFunction +=  [transferFunction]
        return self
    def removeTransferFunction(self, transferFunction):
        self.__transferFunction = [x for x in self.__transferFunction if x not in transferFunction]
        return self.__transferFunction
    def getTransferFunction(self, transferFunction = None):
        return self.__transferFunction
    def transferFunction_changed(self, transferFunction = None):
        return self.__transferFunction
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<OpacityMapVolumeStyle'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<transferFunction'
        if self.__transferFunction is not None:
           for s in self.__transferFunction:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__transferFunction is not None:
           for s in self.__transferFunction:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</transferFunction>'
        str += '</OpacityMapVolumeStyle>'
        return str


class OrientationChaser(X3DChaserNode):
    def __init__(self, **kwargs):
        super(OrientationChaser, self).__init__(**kwargs)
        duration  = kwargs.pop("duration", 1)
        if duration == None or duration  <  0:
            return None
        self.__duration = duration
        initialDestination  = kwargs.pop("initialDestination", [0, 1, 0, 0])
        self.__initialDestination = initialDestination
        initialValue  = kwargs.pop("initialValue", [0, 1, 0, 0])
        self.__initialValue = initialValue
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        destination  = kwargs.pop("destination", None)
        self.__destination = destination
        value  = kwargs.pop("value", None)
        self.__value = value
        value_changed  = kwargs.pop("value_changed", None)
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def isActive(self, Active = None):
        return self.__Active
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def destination(self):
        return self.__destination
    @destination.setter
    def destination(self, value = None):
        self.__destination = [value]
    def set_destination(self, destination = None):
        self.__destination = [destination]
        return self
    @property
    def value(self):
        return self.__value
    @value.setter
    def value(self, value = None):
        self.__value = [value]
    def set_value(self, value = None):
        self.__value = [value]
        return self
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<OrientationChaser'
        if self.__duration is not None:
            if isinstance(self.__duration, six.string_types):
                str += ' duration="'+self.__duration+'"'
            else:
                str += ' duration="'+self.__duration[0]+'"'
        if self.__initialDestination is not None:
            if isinstance(self.__initialDestination, six.string_types):
                str += ' initialDestination="'+self.__initialDestination+'"'
            else:
                str += ' initialDestination="'+self.__initialDestination[0]+'"'
        if self.__initialValue is not None:
            if isinstance(self.__initialValue, six.string_types):
                str += ' initialValue="'+self.__initialValue+'"'
            else:
                str += ' initialValue="'+self.__initialValue[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__destination is not None:
            if isinstance(self.__destination, six.string_types):
                str += ' destination="'+self.__destination+'"'
            else:
                str += ' destination="'+self.__destination[0]+'"'
        if self.__value is not None:
            if isinstance(self.__value, six.string_types):
                str += ' value="'+self.__value+'"'
            else:
                str += ' value="'+self.__value[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</OrientationChaser>'
        return str


class OrientationDamper(X3DDamperNode):
    def __init__(self, **kwargs):
        super(OrientationDamper, self).__init__(**kwargs)
        initialDestination  = kwargs.pop("initialDestination", [0, 1, 0, 0])
        self.__initialDestination = initialDestination
        initialValue  = kwargs.pop("initialValue", [0, 1, 0, 0])
        self.__initialValue = initialValue
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        order  = kwargs.pop("order", 3)
        if order == None or order  <  0:
            return None
        if order == None or order  >  5:
            return None
        self.__order = order
        destination  = kwargs.pop("destination", None)
        self.__destination = destination
        value  = kwargs.pop("value", None)
        self.__value = value
        tau  = kwargs.pop("tau", 0.3)
        if tau == None or tau  <  0:
            return None
        self.__tau = tau
        tolerance  = kwargs.pop("tolerance", -1)
        self.__tolerance = tolerance
        value_changed  = kwargs.pop("value_changed", None)
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def isActive(self, Active = None):
        return self.__Active
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def destination(self):
        return self.__destination
    @destination.setter
    def destination(self, value = None):
        self.__destination = [value]
    def set_destination(self, destination = None):
        self.__destination = [destination]
        return self
    @property
    def value(self):
        return self.__value
    @value.setter
    def value(self, value = None):
        self.__value = [value]
    def set_value(self, value = None):
        self.__value = [value]
        return self
    @property
    def tau(self):
        return self.__tau
    @tau.setter
    def tau(self, value = 0.3):
        if value == None or value  <  0:
            return None
        self.__tau = [value]
    def setTau(self, tau = 0.3):
        if tau == None or tau  <  0:
            return None
        self.__tau = [tau]
        return self
    def addTau(self, tau = 0.3):
        if tau == None or tau  <  0:
            return None
        if self.__tau == None:            self.__tau =  []
        self.__tau +=  [tau]
        return self
    def removeTau(self, tau):
        self.__tau = [x for x in self.__tau if x not in tau]
        return self.__tau
    def getTau(self, tau = 0.3):
        return self.__tau
    def tau_changed(self, tau = 0.3):
        return self.__tau
    @property
    def tolerance(self):
        return self.__tolerance
    @tolerance.setter
    def tolerance(self, value = -1):
        self.__tolerance = [value]
    def setTolerance(self, tolerance = -1):
        self.__tolerance = [tolerance]
        return self
    def addTolerance(self, tolerance = -1):
        if self.__tolerance == None:            self.__tolerance =  []
        self.__tolerance +=  [tolerance]
        return self
    def removeTolerance(self, tolerance):
        self.__tolerance = [x for x in self.__tolerance if x not in tolerance]
        return self.__tolerance
    def getTolerance(self, tolerance = -1):
        return self.__tolerance
    def tolerance_changed(self, tolerance = -1):
        return self.__tolerance
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<OrientationDamper'
        if self.__initialDestination is not None:
            if isinstance(self.__initialDestination, six.string_types):
                str += ' initialDestination="'+self.__initialDestination+'"'
            else:
                str += ' initialDestination="'+self.__initialDestination[0]+'"'
        if self.__initialValue is not None:
            if isinstance(self.__initialValue, six.string_types):
                str += ' initialValue="'+self.__initialValue+'"'
            else:
                str += ' initialValue="'+self.__initialValue[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__order is not None:
            if isinstance(self.__order, six.string_types):
                str += ' order="'+self.__order+'"'
            else:
                str += ' order="'+self.__order[0]+'"'
        if self.__destination is not None:
            if isinstance(self.__destination, six.string_types):
                str += ' destination="'+self.__destination+'"'
            else:
                str += ' destination="'+self.__destination[0]+'"'
        if self.__value is not None:
            if isinstance(self.__value, six.string_types):
                str += ' value="'+self.__value+'"'
            else:
                str += ' value="'+self.__value[0]+'"'
        if self.__tau is not None:
            if isinstance(self.__tau, six.string_types):
                str += ' tau="'+self.__tau+'"'
            else:
                str += ' tau="'+self.__tau[0]+'"'
        if self.__tolerance is not None:
            if isinstance(self.__tolerance, six.string_types):
                str += ' tolerance="'+self.__tolerance+'"'
            else:
                str += ' tolerance="'+self.__tolerance[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</OrientationDamper>'
        return str


class OrientationInterpolator(X3DInterpolatorNode):
    def __init__(self, **kwargs):
        super(OrientationInterpolator, self).__init__(**kwargs)
        key  = kwargs.pop("key", None)
        self.__key = key
        keyValue  = kwargs.pop("keyValue", None)
        self.__keyValue = keyValue
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        fraction  = kwargs.pop("fraction", None)
        self.__fraction = fraction
        value_changed  = kwargs.pop("value_changed", None)
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def key(self):
        return self.__key
    @key.setter
    def key(self, value = None):
        self.__key = [value]
    def setKey(self, key = None):
        self.__key = [key]
        return self
    def addKey(self, key = None):
        if self.__key == None:            self.__key =  []
        self.__key +=  [key]
        return self
    def removeKey(self, key):
        self.__key = [x for x in self.__key if x not in key]
        return self.__key
    def getKey(self, key = None):
        return self.__key
    def key_changed(self, key = None):
        return self.__key
    @property
    def keyValue(self):
        return self.__keyValue
    @keyValue.setter
    def keyValue(self, value = None):
        self.__keyValue = [value]
    def setKeyValue(self, keyValue = None):
        self.__keyValue = [keyValue]
        return self
    def addKeyValue(self, keyValue = None):
        if self.__keyValue == None:            self.__keyValue =  []
        self.__keyValue +=  [keyValue]
        return self
    def removeKeyValue(self, keyValue):
        self.__keyValue = [x for x in self.__keyValue if x not in keyValue]
        return self.__keyValue
    def getKeyValue(self, keyValue = None):
        return self.__keyValue
    def keyValue_changed(self, keyValue = None):
        return self.__keyValue
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def fraction(self):
        return self.__fraction
    @fraction.setter
    def fraction(self, value = None):
        self.__fraction = [value]
    def set_fraction(self, fraction = None):
        self.__fraction = [fraction]
        return self
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    @property
    def IS(self):
        return self.__IS
    @IS.setter
    def IS(self, value = None):
        self.__IS = [value]
    def setIS(self, IS = None):
        self.__IS = [IS]
        return self
    def addIS(self, IS = None):
        if self.__IS == None:            self.__IS =  []
        self.__IS +=  [IS]
        return self
    def removeIS(self, IS):
        self.__IS = [x for x in self.__IS if x not in IS]
        return self.__IS
    def getIS(self, IS = None):
        return self.__IS
    def IS_changed(self, IS = None):
        return self.__IS
    def toXML(self):
        str = ''
        str += '<OrientationInterpolator'
        if self.__key is not None:
            if isinstance(self.__key, six.string_types):
                str += ' key="'+self.__key+'"'
            else:
                str += ' key="'+self.__key[0]+'"'
        if self.__keyValue is not None:
            if isinstance(self.__keyValue, six.string_types):
                str += ' keyValue="'+self.__keyValue+'"'
            else:
                str += ' keyValue="'+self.__keyValue[0]+'"'
        if self.__fraction is not None:
            if isinstance(self.__fraction, six.string_types):
                str += ' fraction="'+self.__fraction+'"'
            else:
                str += ' fraction="'+self.__fraction[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</OrientationInterpolator>'
        return str


class OrthoViewpoint(X3DViewpointNode):
    def __init__(self, **kwargs):
        super(OrthoViewpoint, self).__init__(**kwargs)
        bindTime  = kwargs.pop("bindTime", None)
        self.__bindTime = bindTime
        centerOfRotation  = kwargs.pop("centerOfRotation", [0, 0, 0])
        self.__centerOfRotation = centerOfRotation
        description  = kwargs.pop("description", None)
        self.__description = description
        fieldOfView  = kwargs.pop("fieldOfView", [-1, -1, 1, 1])
        self.__fieldOfView = fieldOfView
        Bound  = kwargs.pop("Bound", None)
        self.__Bound = Bound
        jump  = kwargs.pop("jump", True)
        self.__jump = jump
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        orientation  = kwargs.pop("orientation", [0, 0, 1, 0])
        self.__orientation = orientation
        position  = kwargs.pop("position", [0, 0, 10])
        self.__position = position
        retainUserOffsets  = kwargs.pop("retainUserOffsets", False)
        self.__retainUserOffsets = retainUserOffsets
        bind  = kwargs.pop("bind", None)
        self.__bind = bind
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def removeBindTime(self, bindTime):
        self.__bindTime = [x for x in self.__bindTime if x not in bindTime]
        return self.__bindTime
    def getBindTime(self, bindTime = None):
        return self.__bindTime
    def bindTime_changed(self, bindTime = None):
        return self.__bindTime
    @property
    def centerOfRotation(self):
        return self.__centerOfRotation
    @centerOfRotation.setter
    def centerOfRotation(self, value = [0, 0, 0]):
        self.__centerOfRotation = [value]
    def setCenterOfRotation(self, centerOfRotation = [0, 0, 0]):
        self.__centerOfRotation = [centerOfRotation]
        return self
    def addCenterOfRotation(self, centerOfRotation = [0, 0, 0]):
        if self.__centerOfRotation == None:            self.__centerOfRotation =  []
        self.__centerOfRotation +=  [centerOfRotation]
        return self
    def removeCenterOfRotation(self, centerOfRotation):
        self.__centerOfRotation = [x for x in self.__centerOfRotation if x not in centerOfRotation]
        return self.__centerOfRotation
    def getCenterOfRotation(self, centerOfRotation = [0, 0, 0]):
        return self.__centerOfRotation
    def centerOfRotation_changed(self, centerOfRotation = [0, 0, 0]):
        return self.__centerOfRotation
    @property
    def description(self):
        return self.__description
    @description.setter
    def description(self, value = None):
        self.__description = [value]
    def setDescription(self, description = None):
        self.__description = [description]
        return self
    def addDescription(self, description = None):
        if self.__description == None:            self.__description =  []
        self.__description +=  [description]
        return self
    def removeDescription(self, description):
        self.__description = [x for x in self.__description if x not in description]
        return self.__description
    def getDescription(self, description = None):
        return self.__description
    def description_changed(self, description = None):
        return self.__description
    @property
    def fieldOfView(self):
        return self.__fieldOfView
    @fieldOfView.setter
    def fieldOfView(self, value = [-1, -1, 1, 1]):
        self.__fieldOfView = [value]
    def setFieldOfView(self, fieldOfView = [-1, -1, 1, 1]):
        self.__fieldOfView = [fieldOfView]
        return self
    def addFieldOfView(self, fieldOfView = [-1, -1, 1, 1]):
        if self.__fieldOfView == None:            self.__fieldOfView =  []
        self.__fieldOfView +=  [fieldOfView]
        return self
    def removeFieldOfView(self, fieldOfView):
        self.__fieldOfView = [x for x in self.__fieldOfView if x not in fieldOfView]
        return self.__fieldOfView
    def getFieldOfView(self, fieldOfView = [-1, -1, 1, 1]):
        return self.__fieldOfView
    def fieldOfView_changed(self, fieldOfView = [-1, -1, 1, 1]):
        return self.__fieldOfView
    def isBound(self, Bound = None):
        return self.__Bound
    @property
    def jump(self):
        return self.__jump
    @jump.setter
    def jump(self, value = True):
        self.__jump = [value]
    def setJump(self, jump = True):
        self.__jump = [jump]
        return self
    def addJump(self, jump = True):
        if self.__jump == None:            self.__jump =  []
        self.__jump +=  [jump]
        return self
    def removeJump(self, jump):
        self.__jump = [x for x in self.__jump if x not in jump]
        return self.__jump
    def isJump(self, jump = True):
        return self.__jump
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def orientation(self):
        return self.__orientation
    @orientation.setter
    def orientation(self, value = [0, 0, 1, 0]):
        self.__orientation = [value]
    def setOrientation(self, orientation = [0, 0, 1, 0]):
        self.__orientation = [orientation]
        return self
    def addOrientation(self, orientation = [0, 0, 1, 0]):
        if self.__orientation == None:            self.__orientation =  []
        self.__orientation +=  [orientation]
        return self
    def removeOrientation(self, orientation):
        self.__orientation = [x for x in self.__orientation if x not in orientation]
        return self.__orientation
    def getOrientation(self, orientation = [0, 0, 1, 0]):
        return self.__orientation
    def orientation_changed(self, orientation = [0, 0, 1, 0]):
        return self.__orientation
    @property
    def position(self):
        return self.__position
    @position.setter
    def position(self, value = [0, 0, 10]):
        self.__position = [value]
    def setPosition(self, position = [0, 0, 10]):
        self.__position = [position]
        return self
    def addPosition(self, position = [0, 0, 10]):
        if self.__position == None:            self.__position =  []
        self.__position +=  [position]
        return self
    def removePosition(self, position):
        self.__position = [x for x in self.__position if x not in position]
        return self.__position
    def getPosition(self, position = [0, 0, 10]):
        return self.__position
    def position_changed(self, position = [0, 0, 10]):
        return self.__position
    @property
    def retainUserOffsets(self):
        return self.__retainUserOffsets
    @retainUserOffsets.setter
    def retainUserOffsets(self, value = False):
        self.__retainUserOffsets = [value]
    def setRetainUserOffsets(self, retainUserOffsets = False):
        self.__retainUserOffsets = [retainUserOffsets]
        return self
    def addRetainUserOffsets(self, retainUserOffsets = False):
        if self.__retainUserOffsets == None:            self.__retainUserOffsets =  []
        self.__retainUserOffsets +=  [retainUserOffsets]
        return self
    def removeRetainUserOffsets(self, retainUserOffsets):
        self.__retainUserOffsets = [x for x in self.__retainUserOffsets if x not in retainUserOffsets]
        return self.__retainUserOffsets
    def isRetainUserOffsets(self, retainUserOffsets = False):
        return self.__retainUserOffsets
    @property
    def bind(self):
        return self.__bind
    @bind.setter
    def bind(self, value = None):
        self.__bind = [value]
    def set_bind(self, bind = None):
        self.__bind = [bind]
        return self
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<OrthoViewpoint'
        if self.__bindTime is not None:
            if isinstance(self.__bindTime, six.string_types):
                str += ' bindTime="'+self.__bindTime+'"'
            else:
                str += ' bindTime="'+self.__bindTime[0]+'"'
        if self.__centerOfRotation is not None:
            if isinstance(self.__centerOfRotation, six.string_types):
                str += ' centerOfRotation="'+self.__centerOfRotation+'"'
            else:
                str += ' centerOfRotation="'+self.__centerOfRotation[0]+'"'
        if self.__description is not None:
            if isinstance(self.__description, six.string_types):
                str += ' description="'+self.__description+'"'
            else:
                str += ' description="'+self.__description[0]+'"'
        if self.__fieldOfView is not None:
            if isinstance(self.__fieldOfView, six.string_types):
                str += ' fieldOfView="'+self.__fieldOfView+'"'
            else:
                str += ' fieldOfView="'+self.__fieldOfView[0]+'"'
        if self.__Bound is not None:
            if isinstance(self.__Bound, six.string_types):
                str += ' Bound="'+self.__Bound+'"'
            else:
                str += ' Bound="'+self.__Bound[0]+'"'
        if self.__jump is not None:
            if isinstance(self.__jump, six.string_types):
                str += ' jump="'+self.__jump+'"'
            else:
                str += ' jump="'+self.__jump[0]+'"'
        if self.__orientation is not None:
            if isinstance(self.__orientation, six.string_types):
                str += ' orientation="'+self.__orientation+'"'
            else:
                str += ' orientation="'+self.__orientation[0]+'"'
        if self.__position is not None:
            if isinstance(self.__position, six.string_types):
                str += ' position="'+self.__position+'"'
            else:
                str += ' position="'+self.__position[0]+'"'
        if self.__retainUserOffsets is not None:
            if isinstance(self.__retainUserOffsets, six.string_types):
                str += ' retainUserOffsets="'+self.__retainUserOffsets+'"'
            else:
                str += ' retainUserOffsets="'+self.__retainUserOffsets[0]+'"'
        if self.__bind is not None:
            if isinstance(self.__bind, six.string_types):
                str += ' bind="'+self.__bind+'"'
            else:
                str += ' bind="'+self.__bind[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</OrthoViewpoint>'
        return str


class PackagedShader(X3DUrlObject, X3DProgrammableShaderObject, X3DShaderNode):
    def __init__(self, **kwargs):
        super(PackagedShader, self).__init__(**kwargs)
        activate  = kwargs.pop("activate", None)
        self.__activate = activate
        Selected  = kwargs.pop("Selected", None)
        self.__Selected = Selected
        Valid  = kwargs.pop("Valid", None)
        self.__Valid = Valid
        language  = kwargs.pop("language", None)
        self.__language = language
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        url  = kwargs.pop("url", None)
        self.__url = url
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def activate(self):
        return self.__activate
    @activate.setter
    def activate(self, value = None):
        self.__activate = [value]
    def setActivate(self, activate = None):
        self.__activate = [activate]
        return self
    def addActivate(self, activate = None):
        if self.__activate == None:            self.__activate =  []
        self.__activate +=  [activate]
        return self
    def isSelected(self, Selected = None):
        return self.__Selected
    def isValid(self, Valid = None):
        return self.__Valid
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def url(self):
        return self.__url
    @url.setter
    def url(self, value = None):
        self.__url = [value]
    def setUrl(self, url = None):
        self.__url = [url]
        return self
    def addUrl(self, url = None):
        if self.__url == None:            self.__url =  []
        self.__url +=  [url]
        return self
    def removeUrl(self, url):
        self.__url = [x for x in self.__url if x not in url]
        return self.__url
    def getUrl(self, url = None):
        return self.__url
    def url_changed(self, url = None):
        return self.__url
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<PackagedShader'
        if self.__activate is not None:
            if isinstance(self.__activate, six.string_types):
                str += ' activate="'+self.__activate+'"'
            else:
                str += ' activate="'+self.__activate[0]+'"'
        if self.__Selected is not None:
            if isinstance(self.__Selected, six.string_types):
                str += ' Selected="'+self.__Selected+'"'
            else:
                str += ' Selected="'+self.__Selected[0]+'"'
        if self.__Valid is not None:
            if isinstance(self.__Valid, six.string_types):
                str += ' Valid="'+self.__Valid+'"'
            else:
                str += ' Valid="'+self.__Valid[0]+'"'
        if self.__language is not None:
            if isinstance(self.__language, six.string_types):
                str += ' language="'+self.__language+'"'
            else:
                str += ' language="'+self.__language[0]+'"'
        if self.__url is not None:
            if isinstance(self.__url, six.string_types):
                str += ' url="'+self.__url+'"'
            else:
                str += ' url="'+self.__url[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</PackagedShader>'
        return str


class ParticleSystem(X3DShapeNode):
    def __init__(self, **kwargs):
        super(ParticleSystem, self).__init__(**kwargs)
        appearance  = kwargs.pop("appearance", None)
        self.__appearance = appearance
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        colorKey  = kwargs.pop("colorKey", None)
        if colorKey == None or len(colorKey) <= 0 or min(colorKey)  <  0:
            return None
        self.__colorKey = colorKey
        colorRamp  = kwargs.pop("colorRamp", None)
        self.__colorRamp = colorRamp
        createParticles  = kwargs.pop("createParticles", True)
        self.__createParticles = createParticles
        emitter  = kwargs.pop("emitter", None)
        self.__emitter = emitter
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        geometry  = kwargs.pop("geometry", None)
        self.__geometry = geometry
        geometry  = kwargs.pop("geometry", None)
        self.__geometry = geometry
        geometryType  = kwargs.pop("geometryType", "QUAD")
        self.__geometryType = geometryType
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        lifetimeVariation  = kwargs.pop("lifetimeVariation", 0.25)
        if lifetimeVariation == None or lifetimeVariation  <  0:
            return None
        if lifetimeVariation == None or lifetimeVariation  >  1:
            return None
        self.__lifetimeVariation = lifetimeVariation
        maxParticles  = kwargs.pop("maxParticles", 200)
        if maxParticles == None or maxParticles  <  0:
            return None
        self.__maxParticles = maxParticles
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        particleLifetime  = kwargs.pop("particleLifetime", 5)
        if particleLifetime == None or particleLifetime  <  0:
            return None
        self.__particleLifetime = particleLifetime
        particleSize  = kwargs.pop("particleSize", [0.02, 0.02])
        if particleSize == None or len(particleSize) <= 0 or min(particleSize)  <  0:
            return None
        self.__particleSize = particleSize
        physics  = kwargs.pop("physics", None)
        self.__physics = physics
        texCoordKey  = kwargs.pop("texCoordKey", None)
        if texCoordKey == None or len(texCoordKey) <= 0 or min(texCoordKey)  <  0:
            return None
        self.__texCoordKey = texCoordKey
        texCoordRamp  = kwargs.pop("texCoordRamp", None)
        self.__texCoordRamp = texCoordRamp
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def appearance(self):
        return self.__appearance
    @appearance.setter
    def appearance(self, value = None):
        self.__appearance = [value]
    def setAppearance(self, appearance = None):
        self.__appearance = [appearance]
        return self
    def addAppearance(self, appearance = None):
        if self.__appearance == None:            self.__appearance =  []
        self.__appearance +=  [appearance]
        return self
    def removeAppearance(self, appearance):
        self.__appearance = [x for x in self.__appearance if x not in appearance]
        return self.__appearance
    def getAppearance(self, appearance = None):
        return self.__appearance
    def appearance_changed(self, appearance = None):
        return self.__appearance
    @property
    def createParticles(self):
        return self.__createParticles
    @createParticles.setter
    def createParticles(self, value = True):
        self.__createParticles = [value]
    def setCreateParticles(self, createParticles = True):
        self.__createParticles = [createParticles]
        return self
    def addCreateParticles(self, createParticles = True):
        if self.__createParticles == None:            self.__createParticles =  []
        self.__createParticles +=  [createParticles]
        return self
    def removeCreateParticles(self, createParticles):
        self.__createParticles = [x for x in self.__createParticles if x not in createParticles]
        return self.__createParticles
    def isCreateParticles(self, createParticles = True):
        return self.__createParticles
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def geometry(self):
        return self.__geometry
    @geometry.setter
    def geometry(self, value = None):
        self.__geometry = [value]
    def setGeometry(self, geometry = None):
        self.__geometry = [geometry]
        return self
    def addGeometry(self, geometry = None):
        if self.__geometry == None:            self.__geometry =  []
        self.__geometry +=  [geometry]
        return self
    def removeGeometry(self, geometry):
        self.__geometry = [x for x in self.__geometry if x not in geometry]
        return self.__geometry
    def getGeometry(self, geometry = None):
        return self.__geometry
    def geometry_changed(self, geometry = None):
        return self.__geometry
    @property
    def geometry(self):
        return self.__geometry
    @geometry.setter
    def geometry(self, value = None):
        self.__geometry = [value]
    def setGeometry(self, geometry = None):
        self.__geometry = [geometry]
        return self
    def addGeometry(self, geometry = None):
        if self.__geometry == None:            self.__geometry =  []
        self.__geometry +=  [geometry]
        return self
    def removeGeometry(self, geometry):
        self.__geometry = [x for x in self.__geometry if x not in geometry]
        return self.__geometry
    def getGeometry(self, geometry = None):
        return self.__geometry
    def geometry_changed(self, geometry = None):
        return self.__geometry
    def isActive(self, Active = None):
        return self.__Active
    @property
    def lifetimeVariation(self):
        return self.__lifetimeVariation
    @lifetimeVariation.setter
    def lifetimeVariation(self, value = 0.25):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__lifetimeVariation = [value]
    def setLifetimeVariation(self, lifetimeVariation = 0.25):
        if lifetimeVariation == None or lifetimeVariation  <  0:
            return None
        if lifetimeVariation == None or lifetimeVariation  >  1:
            return None
        self.__lifetimeVariation = [lifetimeVariation]
        return self
    def addLifetimeVariation(self, lifetimeVariation = 0.25):
        if lifetimeVariation == None or lifetimeVariation  <  0:
            return None
        if lifetimeVariation == None or lifetimeVariation  >  1:
            return None
        if self.__lifetimeVariation == None:            self.__lifetimeVariation =  []
        self.__lifetimeVariation +=  [lifetimeVariation]
        return self
    def removeLifetimeVariation(self, lifetimeVariation):
        self.__lifetimeVariation = [x for x in self.__lifetimeVariation if x not in lifetimeVariation]
        return self.__lifetimeVariation
    def getLifetimeVariation(self, lifetimeVariation = 0.25):
        return self.__lifetimeVariation
    def lifetimeVariation_changed(self, lifetimeVariation = 0.25):
        return self.__lifetimeVariation
    @property
    def maxParticles(self):
        return self.__maxParticles
    @maxParticles.setter
    def maxParticles(self, value = 200):
        if value == None or value  <  0:
            return None
        self.__maxParticles = [value]
    def setMaxParticles(self, maxParticles = 200):
        if maxParticles == None or maxParticles  <  0:
            return None
        self.__maxParticles = [maxParticles]
        return self
    def addMaxParticles(self, maxParticles = 200):
        if maxParticles == None or maxParticles  <  0:
            return None
        if self.__maxParticles == None:            self.__maxParticles =  []
        self.__maxParticles +=  [maxParticles]
        return self
    def removeMaxParticles(self, maxParticles):
        self.__maxParticles = [x for x in self.__maxParticles if x not in maxParticles]
        return self.__maxParticles
    def getMaxParticles(self, maxParticles = 200):
        return self.__maxParticles
    def maxParticles_changed(self, maxParticles = 200):
        return self.__maxParticles
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def particleLifetime(self):
        return self.__particleLifetime
    @particleLifetime.setter
    def particleLifetime(self, value = 5):
        if value == None or value  <  0:
            return None
        self.__particleLifetime = [value]
    def setParticleLifetime(self, particleLifetime = 5):
        if particleLifetime == None or particleLifetime  <  0:
            return None
        self.__particleLifetime = [particleLifetime]
        return self
    def addParticleLifetime(self, particleLifetime = 5):
        if particleLifetime == None or particleLifetime  <  0:
            return None
        if self.__particleLifetime == None:            self.__particleLifetime =  []
        self.__particleLifetime +=  [particleLifetime]
        return self
    def removeParticleLifetime(self, particleLifetime):
        self.__particleLifetime = [x for x in self.__particleLifetime if x not in particleLifetime]
        return self.__particleLifetime
    def getParticleLifetime(self, particleLifetime = 5):
        return self.__particleLifetime
    def particleLifetime_changed(self, particleLifetime = 5):
        return self.__particleLifetime
    @property
    def particleSize(self):
        return self.__particleSize
    @particleSize.setter
    def particleSize(self, value = [0.02, 0.02]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        self.__particleSize = [value]
    def setParticleSize(self, particleSize = [0.02, 0.02]):
        if particleSize == None or len(particleSize) <= 0 or min(particleSize)  <  0:
            return None
        self.__particleSize = [particleSize]
        return self
    def addParticleSize(self, particleSize = [0.02, 0.02]):
        if particleSize == None or len(particleSize) <= 0 or min(particleSize)  <  0:
            return None
        if self.__particleSize == None:            self.__particleSize =  []
        self.__particleSize +=  [particleSize]
        return self
    def removeParticleSize(self, particleSize):
        self.__particleSize = [x for x in self.__particleSize if x not in particleSize]
        return self.__particleSize
    def getParticleSize(self, particleSize = [0.02, 0.02]):
        return self.__particleSize
    def particleSize_changed(self, particleSize = [0.02, 0.02]):
        return self.__particleSize
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ParticleSystem'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__colorKey is not None:
            if isinstance(self.__colorKey, six.string_types):
                str += ' colorKey="'+self.__colorKey+'"'
            else:
                str += ' colorKey="'+self.__colorKey[0]+'"'
        if self.__createParticles is not None:
            if isinstance(self.__createParticles, six.string_types):
                str += ' createParticles="'+self.__createParticles+'"'
            else:
                str += ' createParticles="'+self.__createParticles[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__geometryType is not None:
            if isinstance(self.__geometryType, six.string_types):
                str += ' geometryType="'+self.__geometryType+'"'
            else:
                str += ' geometryType="'+self.__geometryType[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__lifetimeVariation is not None:
            if isinstance(self.__lifetimeVariation, six.string_types):
                str += ' lifetimeVariation="'+self.__lifetimeVariation+'"'
            else:
                str += ' lifetimeVariation="'+self.__lifetimeVariation[0]+'"'
        if self.__maxParticles is not None:
            if isinstance(self.__maxParticles, six.string_types):
                str += ' maxParticles="'+self.__maxParticles+'"'
            else:
                str += ' maxParticles="'+self.__maxParticles[0]+'"'
        if self.__particleLifetime is not None:
            if isinstance(self.__particleLifetime, six.string_types):
                str += ' particleLifetime="'+self.__particleLifetime+'"'
            else:
                str += ' particleLifetime="'+self.__particleLifetime[0]+'"'
        if self.__particleSize is not None:
            if isinstance(self.__particleSize, six.string_types):
                str += ' particleSize="'+self.__particleSize+'"'
            else:
                str += ' particleSize="'+self.__particleSize[0]+'"'
        if self.__texCoordKey is not None:
            if isinstance(self.__texCoordKey, six.string_types):
                str += ' texCoordKey="'+self.__texCoordKey+'"'
            else:
                str += ' texCoordKey="'+self.__texCoordKey[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<appearance'
        if self.__appearance is not None:
           for s in self.__appearance:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__appearance is not None:
           for s in self.__appearance:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</appearance>'
        str += '<colorRamp'
        if self.__colorRamp is not None:
           for s in self.__colorRamp:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__colorRamp is not None:
           for s in self.__colorRamp:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</colorRamp>'
        str += '<emitter'
        if self.__emitter is not None:
           for s in self.__emitter:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__emitter is not None:
           for s in self.__emitter:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</emitter>'
        str += '<geometry'
        if self.__geometry is not None:
           for s in self.__geometry:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__geometry is not None:
           for s in self.__geometry:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</geometry>'
        str += '<geometry'
        if self.__geometry is not None:
           for s in self.__geometry:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__geometry is not None:
           for s in self.__geometry:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</geometry>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<physics'
        if self.__physics is not None:
           for s in self.__physics:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__physics is not None:
           for s in self.__physics:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</physics>'
        str += '<texCoordRamp'
        if self.__texCoordRamp is not None:
           for s in self.__texCoordRamp:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__texCoordRamp is not None:
           for s in self.__texCoordRamp:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</texCoordRamp>'
        str += '</ParticleSystem>'
        return str


class PickableGroup(X3DPickableObject, X3DGroupingNode):
    def __init__(self, **kwargs):
        super(PickableGroup, self).__init__(**kwargs)
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        children  = kwargs.pop("children", None)
        self.__children = children
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        objectType  = kwargs.pop("objectType", ["ALL"])
        self.__objectType = objectType
        pickable  = kwargs.pop("pickable", True)
        self.__pickable = pickable
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    def addChildren(self, Children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [Children]
        return self
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def objectType(self):
        return self.__objectType
    @objectType.setter
    def objectType(self, value = ["ALL"]):
        self.__objectType = [value]
    def setObjectType(self, objectType = ["ALL"]):
        self.__objectType = [objectType]
        return self
    def addObjectType(self, objectType = ["ALL"]):
        if self.__objectType == None:            self.__objectType =  []
        self.__objectType +=  [objectType]
        return self
    def removeObjectType(self, objectType):
        self.__objectType = [x for x in self.__objectType if x not in objectType]
        return self.__objectType
    def getObjectType(self, objectType = ["ALL"]):
        return self.__objectType
    def objectType_changed(self, objectType = ["ALL"]):
        return self.__objectType
    @property
    def pickable(self):
        return self.__pickable
    @pickable.setter
    def pickable(self, value = True):
        self.__pickable = [value]
    def setPickable(self, pickable = True):
        self.__pickable = [pickable]
        return self
    def addPickable(self, pickable = True):
        if self.__pickable == None:            self.__pickable =  []
        self.__pickable +=  [pickable]
        return self
    def removePickable(self, pickable):
        self.__pickable = [x for x in self.__pickable if x not in pickable]
        return self.__pickable
    def isPickable(self, pickable = True):
        return self.__pickable
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<PickableGroup'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__objectType is not None:
            if isinstance(self.__objectType, six.string_types):
                str += ' objectType="'+self.__objectType+'"'
            else:
                str += ' objectType="'+self.__objectType[0]+'"'
        if self.__pickable is not None:
            if isinstance(self.__pickable, six.string_types):
                str += ' pickable="'+self.__pickable+'"'
            else:
                str += ' pickable="'+self.__pickable[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '</PickableGroup>'
        return str


class PixelTexture(X3DTexture2DNode):
    def __init__(self, **kwargs):
        super(PixelTexture, self).__init__(**kwargs)
        image  = kwargs.pop("image", [0, 0, 0])
        self.__image = image
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        repeatS  = kwargs.pop("repeatS", True)
        self.__repeatS = repeatS
        repeatT  = kwargs.pop("repeatT", True)
        self.__repeatT = repeatT
        textureProperties  = kwargs.pop("textureProperties", None)
        self.__textureProperties = textureProperties
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def image(self):
        return self.__image
    @image.setter
    def image(self, value = [0, 0, 0]):
        self.__image = [value]
    def setImage(self, image = [0, 0, 0]):
        self.__image = [image]
        return self
    def addImage(self, image = [0, 0, 0]):
        if self.__image == None:            self.__image =  []
        self.__image +=  [image]
        return self
    def removeImage(self, image):
        self.__image = [x for x in self.__image if x not in image]
        return self.__image
    def getImage(self, image = [0, 0, 0]):
        return self.__image
    def image_changed(self, image = [0, 0, 0]):
        return self.__image
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<PixelTexture'
        if self.__image is not None:
            if isinstance(self.__image, six.string_types):
                str += ' image="'+self.__image+'"'
            else:
                str += ' image="'+self.__image[0]+'"'
        if self.__repeatS is not None:
            if isinstance(self.__repeatS, six.string_types):
                str += ' repeatS="'+self.__repeatS+'"'
            else:
                str += ' repeatS="'+self.__repeatS[0]+'"'
        if self.__repeatT is not None:
            if isinstance(self.__repeatT, six.string_types):
                str += ' repeatT="'+self.__repeatT+'"'
            else:
                str += ' repeatT="'+self.__repeatT[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<textureProperties'
        if self.__textureProperties is not None:
           for s in self.__textureProperties:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__textureProperties is not None:
           for s in self.__textureProperties:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</textureProperties>'
        str += '</PixelTexture>'
        return str


class PixelTexture3D(X3DTexture3DNode):
    def __init__(self, **kwargs):
        super(PixelTexture3D, self).__init__(**kwargs)
        image  = kwargs.pop("image", [0, 0, 0, 0])
        self.__image = image
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        repeatR  = kwargs.pop("repeatR", False)
        self.__repeatR = repeatR
        repeatS  = kwargs.pop("repeatS", False)
        self.__repeatS = repeatS
        repeatT  = kwargs.pop("repeatT", False)
        self.__repeatT = repeatT
        textureProperties  = kwargs.pop("textureProperties", None)
        self.__textureProperties = textureProperties
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def image(self):
        return self.__image
    @image.setter
    def image(self, value = [0, 0, 0, 0]):
        self.__image = [value]
    def setImage(self, image = [0, 0, 0, 0]):
        self.__image = [image]
        return self
    def addImage(self, image = [0, 0, 0, 0]):
        if self.__image == None:            self.__image =  []
        self.__image +=  [image]
        return self
    def removeImage(self, image):
        self.__image = [x for x in self.__image if x not in image]
        return self.__image
    def getImage(self, image = [0, 0, 0, 0]):
        return self.__image
    def image_changed(self, image = [0, 0, 0, 0]):
        return self.__image
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<PixelTexture3D'
        if self.__image is not None:
            if isinstance(self.__image, six.string_types):
                str += ' image="'+self.__image+'"'
            else:
                str += ' image="'+self.__image[0]+'"'
        if self.__repeatR is not None:
            if isinstance(self.__repeatR, six.string_types):
                str += ' repeatR="'+self.__repeatR+'"'
            else:
                str += ' repeatR="'+self.__repeatR[0]+'"'
        if self.__repeatS is not None:
            if isinstance(self.__repeatS, six.string_types):
                str += ' repeatS="'+self.__repeatS+'"'
            else:
                str += ' repeatS="'+self.__repeatS[0]+'"'
        if self.__repeatT is not None:
            if isinstance(self.__repeatT, six.string_types):
                str += ' repeatT="'+self.__repeatT+'"'
            else:
                str += ' repeatT="'+self.__repeatT[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<textureProperties'
        if self.__textureProperties is not None:
           for s in self.__textureProperties:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__textureProperties is not None:
           for s in self.__textureProperties:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</textureProperties>'
        str += '</PixelTexture3D>'
        return str


class PlaneSensor(X3DDragSensorNode):
    def __init__(self, **kwargs):
        super(PlaneSensor, self).__init__(**kwargs)
        autoOffset  = kwargs.pop("autoOffset", True)
        self.__autoOffset = autoOffset
        axisRotation  = kwargs.pop("axisRotation", [0, 1, 0, 0])
        self.__axisRotation = axisRotation
        description  = kwargs.pop("description", None)
        self.__description = description
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        Over  = kwargs.pop("Over", None)
        self.__Over = Over
        maxPosition  = kwargs.pop("maxPosition", [-1, -1])
        self.__maxPosition = maxPosition
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        minPosition  = kwargs.pop("minPosition", [0, 0])
        self.__minPosition = minPosition
        offset  = kwargs.pop("offset", [0, 0, 0])
        self.__offset = offset
        trackPoint_changed  = kwargs.pop("trackPoint_changed", None)
        self.__trackPoint_changed = trackPoint_changed
        translation_changed  = kwargs.pop("translation_changed", None)
        self.__translation_changed = translation_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def autoOffset(self):
        return self.__autoOffset
    @autoOffset.setter
    def autoOffset(self, value = True):
        self.__autoOffset = [value]
    def setAutoOffset(self, autoOffset = True):
        self.__autoOffset = [autoOffset]
        return self
    def addAutoOffset(self, autoOffset = True):
        if self.__autoOffset == None:            self.__autoOffset =  []
        self.__autoOffset +=  [autoOffset]
        return self
    def removeAutoOffset(self, autoOffset):
        self.__autoOffset = [x for x in self.__autoOffset if x not in autoOffset]
        return self.__autoOffset
    def isAutoOffset(self, autoOffset = True):
        return self.__autoOffset
    @property
    def axisRotation(self):
        return self.__axisRotation
    @axisRotation.setter
    def axisRotation(self, value = [0, 1, 0, 0]):
        self.__axisRotation = [value]
    def setAxisRotation(self, axisRotation = [0, 1, 0, 0]):
        self.__axisRotation = [axisRotation]
        return self
    def addAxisRotation(self, axisRotation = [0, 1, 0, 0]):
        if self.__axisRotation == None:            self.__axisRotation =  []
        self.__axisRotation +=  [axisRotation]
        return self
    def removeAxisRotation(self, axisRotation):
        self.__axisRotation = [x for x in self.__axisRotation if x not in axisRotation]
        return self.__axisRotation
    def getAxisRotation(self, axisRotation = [0, 1, 0, 0]):
        return self.__axisRotation
    def axisRotation_changed(self, axisRotation = [0, 1, 0, 0]):
        return self.__axisRotation
    @property
    def description(self):
        return self.__description
    @description.setter
    def description(self, value = None):
        self.__description = [value]
    def setDescription(self, description = None):
        self.__description = [description]
        return self
    def addDescription(self, description = None):
        if self.__description == None:            self.__description =  []
        self.__description +=  [description]
        return self
    def removeDescription(self, description):
        self.__description = [x for x in self.__description if x not in description]
        return self.__description
    def getDescription(self, description = None):
        return self.__description
    def description_changed(self, description = None):
        return self.__description
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    def isActive(self, Active = None):
        return self.__Active
    def isOver(self, Over = None):
        return self.__Over
    @property
    def maxPosition(self):
        return self.__maxPosition
    @maxPosition.setter
    def maxPosition(self, value = [-1, -1]):
        self.__maxPosition = [value]
    def setMaxPosition(self, maxPosition = [-1, -1]):
        self.__maxPosition = [maxPosition]
        return self
    def addMaxPosition(self, maxPosition = [-1, -1]):
        if self.__maxPosition == None:            self.__maxPosition =  []
        self.__maxPosition +=  [maxPosition]
        return self
    def removeMaxPosition(self, maxPosition):
        self.__maxPosition = [x for x in self.__maxPosition if x not in maxPosition]
        return self.__maxPosition
    def getMaxPosition(self, maxPosition = [-1, -1]):
        return self.__maxPosition
    def maxPosition_changed(self, maxPosition = [-1, -1]):
        return self.__maxPosition
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def minPosition(self):
        return self.__minPosition
    @minPosition.setter
    def minPosition(self, value = [0, 0]):
        self.__minPosition = [value]
    def setMinPosition(self, minPosition = [0, 0]):
        self.__minPosition = [minPosition]
        return self
    def addMinPosition(self, minPosition = [0, 0]):
        if self.__minPosition == None:            self.__minPosition =  []
        self.__minPosition +=  [minPosition]
        return self
    def removeMinPosition(self, minPosition):
        self.__minPosition = [x for x in self.__minPosition if x not in minPosition]
        return self.__minPosition
    def getMinPosition(self, minPosition = [0, 0]):
        return self.__minPosition
    def minPosition_changed(self, minPosition = [0, 0]):
        return self.__minPosition
    @property
    def offset(self):
        return self.__offset
    @offset.setter
    def offset(self, value = [0, 0, 0]):
        self.__offset = [value]
    def setOffset(self, offset = [0, 0, 0]):
        self.__offset = [offset]
        return self
    def addOffset(self, offset = [0, 0, 0]):
        if self.__offset == None:            self.__offset =  []
        self.__offset +=  [offset]
        return self
    def removeOffset(self, offset):
        self.__offset = [x for x in self.__offset if x not in offset]
        return self.__offset
    def getOffset(self, offset = [0, 0, 0]):
        return self.__offset
    def offset_changed(self, offset = [0, 0, 0]):
        return self.__offset
    def removetrackPoint_changed(self, trackPoint_changed):
        self.__trackPoint_changed = [x for x in self.__trackPoint_changed if x not in trackPoint_changed]
        return self.__trackPoint_changed
    def gettrackPoint_changed(self, trackPoint_changed = None):
        return self.__trackPoint_changed
    def trackPoint_changed_changed(self, trackPoint_changed = None):
        return self.__trackPoint_changed
    def removetranslation_changed(self, translation_changed):
        self.__translation_changed = [x for x in self.__translation_changed if x not in translation_changed]
        return self.__translation_changed
    def gettranslation_changed(self, translation_changed = None):
        return self.__translation_changed
    def translation_changed_changed(self, translation_changed = None):
        return self.__translation_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<PlaneSensor'
        if self.__autoOffset is not None:
            if isinstance(self.__autoOffset, six.string_types):
                str += ' autoOffset="'+self.__autoOffset+'"'
            else:
                str += ' autoOffset="'+self.__autoOffset[0]+'"'
        if self.__axisRotation is not None:
            if isinstance(self.__axisRotation, six.string_types):
                str += ' axisRotation="'+self.__axisRotation+'"'
            else:
                str += ' axisRotation="'+self.__axisRotation[0]+'"'
        if self.__description is not None:
            if isinstance(self.__description, six.string_types):
                str += ' description="'+self.__description+'"'
            else:
                str += ' description="'+self.__description[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__Over is not None:
            if isinstance(self.__Over, six.string_types):
                str += ' Over="'+self.__Over+'"'
            else:
                str += ' Over="'+self.__Over[0]+'"'
        if self.__maxPosition is not None:
            if isinstance(self.__maxPosition, six.string_types):
                str += ' maxPosition="'+self.__maxPosition+'"'
            else:
                str += ' maxPosition="'+self.__maxPosition[0]+'"'
        if self.__minPosition is not None:
            if isinstance(self.__minPosition, six.string_types):
                str += ' minPosition="'+self.__minPosition+'"'
            else:
                str += ' minPosition="'+self.__minPosition[0]+'"'
        if self.__offset is not None:
            if isinstance(self.__offset, six.string_types):
                str += ' offset="'+self.__offset+'"'
            else:
                str += ' offset="'+self.__offset[0]+'"'
        if self.__trackPoint_changed is not None:
            if isinstance(self.__trackPoint_changed, six.string_types):
                str += ' trackPoint_changed="'+self.__trackPoint_changed+'"'
            else:
                str += ' trackPoint_changed="'+self.__trackPoint_changed[0]+'"'
        if self.__translation_changed is not None:
            if isinstance(self.__translation_changed, six.string_types):
                str += ' translation_changed="'+self.__translation_changed+'"'
            else:
                str += ' translation_changed="'+self.__translation_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</PlaneSensor>'
        return str


class PointEmitter(X3DParticleEmitterNode):
    def __init__(self, **kwargs):
        super(PointEmitter, self).__init__(**kwargs)
        direction  = kwargs.pop("direction", [0, 1, 0])
        self.__direction = direction
        mass  = kwargs.pop("mass", 0)
        if mass == None or mass  <  0:
            return None
        self.__mass = mass
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        position  = kwargs.pop("position", [0, 0, 0])
        self.__position = position
        speed  = kwargs.pop("speed", 0)
        if speed == None or speed  <  0:
            return None
        self.__speed = speed
        surfaceArea  = kwargs.pop("surfaceArea", 0)
        if surfaceArea == None or surfaceArea  <  0:
            return None
        self.__surfaceArea = surfaceArea
        variation  = kwargs.pop("variation", 0.25)
        if variation == None or variation  <  0:
            return None
        self.__variation = variation
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def direction(self):
        return self.__direction
    @direction.setter
    def direction(self, value = [0, 1, 0]):
        self.__direction = [value]
    def setDirection(self, direction = [0, 1, 0]):
        self.__direction = [direction]
        return self
    def addDirection(self, direction = [0, 1, 0]):
        if self.__direction == None:            self.__direction =  []
        self.__direction +=  [direction]
        return self
    def removeDirection(self, direction):
        self.__direction = [x for x in self.__direction if x not in direction]
        return self.__direction
    def getDirection(self, direction = [0, 1, 0]):
        return self.__direction
    def direction_changed(self, direction = [0, 1, 0]):
        return self.__direction
    @property
    def mass(self):
        return self.__mass
    @mass.setter
    def mass(self, value = 0):
        if value == None or value  <  0:
            return None
        self.__mass = [value]
    def setMass(self, mass = 0):
        if mass == None or mass  <  0:
            return None
        self.__mass = [mass]
        return self
    def addMass(self, mass = 0):
        if mass == None or mass  <  0:
            return None
        if self.__mass == None:            self.__mass =  []
        self.__mass +=  [mass]
        return self
    def removeMass(self, mass):
        self.__mass = [x for x in self.__mass if x not in mass]
        return self.__mass
    def getMass(self, mass = 0):
        return self.__mass
    def mass_changed(self, mass = 0):
        return self.__mass
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def position(self):
        return self.__position
    @position.setter
    def position(self, value = [0, 0, 0]):
        self.__position = [value]
    def setPosition(self, position = [0, 0, 0]):
        self.__position = [position]
        return self
    def addPosition(self, position = [0, 0, 0]):
        if self.__position == None:            self.__position =  []
        self.__position +=  [position]
        return self
    def removePosition(self, position):
        self.__position = [x for x in self.__position if x not in position]
        return self.__position
    def getPosition(self, position = [0, 0, 0]):
        return self.__position
    def position_changed(self, position = [0, 0, 0]):
        return self.__position
    @property
    def speed(self):
        return self.__speed
    @speed.setter
    def speed(self, value = 0):
        if value == None or value  <  0:
            return None
        self.__speed = [value]
    def setSpeed(self, speed = 0):
        if speed == None or speed  <  0:
            return None
        self.__speed = [speed]
        return self
    def addSpeed(self, speed = 0):
        if speed == None or speed  <  0:
            return None
        if self.__speed == None:            self.__speed =  []
        self.__speed +=  [speed]
        return self
    def removeSpeed(self, speed):
        self.__speed = [x for x in self.__speed if x not in speed]
        return self.__speed
    def getSpeed(self, speed = 0):
        return self.__speed
    def speed_changed(self, speed = 0):
        return self.__speed
    @property
    def variation(self):
        return self.__variation
    @variation.setter
    def variation(self, value = 0.25):
        if value == None or value  <  0:
            return None
        self.__variation = [value]
    def setVariation(self, variation = 0.25):
        if variation == None or variation  <  0:
            return None
        self.__variation = [variation]
        return self
    def addVariation(self, variation = 0.25):
        if variation == None or variation  <  0:
            return None
        if self.__variation == None:            self.__variation =  []
        self.__variation +=  [variation]
        return self
    def removeVariation(self, variation):
        self.__variation = [x for x in self.__variation if x not in variation]
        return self.__variation
    def getVariation(self, variation = 0.25):
        return self.__variation
    def variation_changed(self, variation = 0.25):
        return self.__variation
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<PointEmitter'
        if self.__direction is not None:
            if isinstance(self.__direction, six.string_types):
                str += ' direction="'+self.__direction+'"'
            else:
                str += ' direction="'+self.__direction[0]+'"'
        if self.__mass is not None:
            if isinstance(self.__mass, six.string_types):
                str += ' mass="'+self.__mass+'"'
            else:
                str += ' mass="'+self.__mass[0]+'"'
        if self.__position is not None:
            if isinstance(self.__position, six.string_types):
                str += ' position="'+self.__position+'"'
            else:
                str += ' position="'+self.__position[0]+'"'
        if self.__speed is not None:
            if isinstance(self.__speed, six.string_types):
                str += ' speed="'+self.__speed+'"'
            else:
                str += ' speed="'+self.__speed[0]+'"'
        if self.__surfaceArea is not None:
            if isinstance(self.__surfaceArea, six.string_types):
                str += ' surfaceArea="'+self.__surfaceArea+'"'
            else:
                str += ' surfaceArea="'+self.__surfaceArea[0]+'"'
        if self.__variation is not None:
            if isinstance(self.__variation, six.string_types):
                str += ' variation="'+self.__variation+'"'
            else:
                str += ' variation="'+self.__variation[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</PointEmitter>'
        return str


class PointLight(X3DLightNode):
    def __init__(self, **kwargs):
        super(PointLight, self).__init__(**kwargs)
        ambientIntensity  = kwargs.pop("ambientIntensity", 0)
        if ambientIntensity == None or ambientIntensity  <  0:
            return None
        if ambientIntensity == None or ambientIntensity  >  1:
            return None
        self.__ambientIntensity = ambientIntensity
        attenuation  = kwargs.pop("attenuation", [1, 0, 0])
        if attenuation == None or len(attenuation) <= 0 or min(attenuation)  <  0:
            return None
        self.__attenuation = attenuation
        color  = kwargs.pop("color", [1, 1, 1])
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        self.__color = color
        global_  = kwargs.pop("global_", True)
        self.__global_ = global_
        intensity  = kwargs.pop("intensity", 1)
        if intensity == None or intensity  <  0:
            return None
        if intensity == None or intensity  >  1:
            return None
        self.__intensity = intensity
        location  = kwargs.pop("location", [0, 0, 0])
        self.__location = location
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        on  = kwargs.pop("on", True)
        self.__on = on
        radius  = kwargs.pop("radius", 100)
        if radius == None or radius  <  0:
            return None
        self.__radius = radius
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def ambientIntensity(self):
        return self.__ambientIntensity
    @ambientIntensity.setter
    def ambientIntensity(self, value = 0):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__ambientIntensity = [value]
    def setAmbientIntensity(self, ambientIntensity = 0):
        if ambientIntensity == None or ambientIntensity  <  0:
            return None
        if ambientIntensity == None or ambientIntensity  >  1:
            return None
        self.__ambientIntensity = [ambientIntensity]
        return self
    def addAmbientIntensity(self, ambientIntensity = 0):
        if ambientIntensity == None or ambientIntensity  <  0:
            return None
        if ambientIntensity == None or ambientIntensity  >  1:
            return None
        if self.__ambientIntensity == None:            self.__ambientIntensity =  []
        self.__ambientIntensity +=  [ambientIntensity]
        return self
    def removeAmbientIntensity(self, ambientIntensity):
        self.__ambientIntensity = [x for x in self.__ambientIntensity if x not in ambientIntensity]
        return self.__ambientIntensity
    def getAmbientIntensity(self, ambientIntensity = 0):
        return self.__ambientIntensity
    def ambientIntensity_changed(self, ambientIntensity = 0):
        return self.__ambientIntensity
    @property
    def attenuation(self):
        return self.__attenuation
    @attenuation.setter
    def attenuation(self, value = [1, 0, 0]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        self.__attenuation = [value]
    def setAttenuation(self, attenuation = [1, 0, 0]):
        if attenuation == None or len(attenuation) <= 0 or min(attenuation)  <  0:
            return None
        self.__attenuation = [attenuation]
        return self
    def addAttenuation(self, attenuation = [1, 0, 0]):
        if attenuation == None or len(attenuation) <= 0 or min(attenuation)  <  0:
            return None
        if self.__attenuation == None:            self.__attenuation =  []
        self.__attenuation +=  [attenuation]
        return self
    def removeAttenuation(self, attenuation):
        self.__attenuation = [x for x in self.__attenuation if x not in attenuation]
        return self.__attenuation
    def getAttenuation(self, attenuation = [1, 0, 0]):
        return self.__attenuation
    def attenuation_changed(self, attenuation = [1, 0, 0]):
        return self.__attenuation
    @property
    def color(self):
        return self.__color
    @color.setter
    def color(self, value = [1, 1, 1]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__color = [value]
    def setColor(self, color = [1, 1, 1]):
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        self.__color = [color]
        return self
    def addColor(self, color = [1, 1, 1]):
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        if self.__color == None:            self.__color =  []
        self.__color +=  [color]
        return self
    def removeColor(self, color):
        self.__color = [x for x in self.__color if x not in color]
        return self.__color
    def getColor(self, color = [1, 1, 1]):
        return self.__color
    def color_changed(self, color = [1, 1, 1]):
        return self.__color
    @property
    def global_(self):
        return self.__global_
    @global_.setter
    def global_(self, value = True):
        self.__global_ = [value]
    def setGlobal(self, global_ = True):
        self.__global_ = [global_]
        return self
    def addGlobal(self, global_ = True):
        if self.__global_ == None:            self.__global_ =  []
        self.__global_ +=  [global_]
        return self
    def removeGlobal(self, global_):
        self.__global_ = [x for x in self.__global_ if x not in global_]
        return self.__global_
    def isGlobal(self, global_ = True):
        return self.__global_
    @property
    def intensity(self):
        return self.__intensity
    @intensity.setter
    def intensity(self, value = 1):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__intensity = [value]
    def setIntensity(self, intensity = 1):
        if intensity == None or intensity  <  0:
            return None
        if intensity == None or intensity  >  1:
            return None
        self.__intensity = [intensity]
        return self
    def addIntensity(self, intensity = 1):
        if intensity == None or intensity  <  0:
            return None
        if intensity == None or intensity  >  1:
            return None
        if self.__intensity == None:            self.__intensity =  []
        self.__intensity +=  [intensity]
        return self
    def removeIntensity(self, intensity):
        self.__intensity = [x for x in self.__intensity if x not in intensity]
        return self.__intensity
    def getIntensity(self, intensity = 1):
        return self.__intensity
    def intensity_changed(self, intensity = 1):
        return self.__intensity
    @property
    def location(self):
        return self.__location
    @location.setter
    def location(self, value = [0, 0, 0]):
        self.__location = [value]
    def setLocation(self, location = [0, 0, 0]):
        self.__location = [location]
        return self
    def addLocation(self, location = [0, 0, 0]):
        if self.__location == None:            self.__location =  []
        self.__location +=  [location]
        return self
    def removeLocation(self, location):
        self.__location = [x for x in self.__location if x not in location]
        return self.__location
    def getLocation(self, location = [0, 0, 0]):
        return self.__location
    def location_changed(self, location = [0, 0, 0]):
        return self.__location
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def on(self):
        return self.__on
    @on.setter
    def on(self, value = True):
        self.__on = [value]
    def setOn(self, on = True):
        self.__on = [on]
        return self
    def addOn(self, on = True):
        if self.__on == None:            self.__on =  []
        self.__on +=  [on]
        return self
    def removeOn(self, on):
        self.__on = [x for x in self.__on if x not in on]
        return self.__on
    def isOn(self, on = True):
        return self.__on
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<PointLight'
        if self.__ambientIntensity is not None:
            if isinstance(self.__ambientIntensity, six.string_types):
                str += ' ambientIntensity="'+self.__ambientIntensity+'"'
            else:
                str += ' ambientIntensity="'+self.__ambientIntensity[0]+'"'
        if self.__attenuation is not None:
            if isinstance(self.__attenuation, six.string_types):
                str += ' attenuation="'+self.__attenuation+'"'
            else:
                str += ' attenuation="'+self.__attenuation[0]+'"'
        if self.__color is not None:
            if isinstance(self.__color, six.string_types):
                str += ' color="'+self.__color+'"'
            else:
                str += ' color="'+self.__color[0]+'"'
        if self.__global_ is not None:
            if isinstance(self.__global_, six.string_types):
                str += ' global_="'+self.__global_+'"'
            else:
                str += ' global_="'+self.__global_[0]+'"'
        if self.__intensity is not None:
            if isinstance(self.__intensity, six.string_types):
                str += ' intensity="'+self.__intensity+'"'
            else:
                str += ' intensity="'+self.__intensity[0]+'"'
        if self.__location is not None:
            if isinstance(self.__location, six.string_types):
                str += ' location="'+self.__location+'"'
            else:
                str += ' location="'+self.__location[0]+'"'
        if self.__on is not None:
            if isinstance(self.__on, six.string_types):
                str += ' on="'+self.__on+'"'
            else:
                str += ' on="'+self.__on[0]+'"'
        if self.__radius is not None:
            if isinstance(self.__radius, six.string_types):
                str += ' radius="'+self.__radius+'"'
            else:
                str += ' radius="'+self.__radius[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</PointLight>'
        return str


class PointPickSensor(X3DPickSensorNode):
    def __init__(self, **kwargs):
        super(PointPickSensor, self).__init__(**kwargs)
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        intersectionType  = kwargs.pop("intersectionType", "BOUNDS")
        self.__intersectionType = intersectionType
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        matchCriterion  = kwargs.pop("matchCriterion", "MATCH_ANY")
        if 'MATCH_ANY' == matchCriterion:
            pass
        elif 'MATCH_EVERY' == matchCriterion:
            pass
        elif 'MATCH_ONLY_ONE' == matchCriterion:
            pass
        else:
            return None
        self.__matchCriterion = matchCriterion
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        objectType  = kwargs.pop("objectType", ["ALL"])
        self.__objectType = objectType
        pickedGeometry  = kwargs.pop("pickedGeometry", None)
        self.__pickedGeometry = pickedGeometry
        pickedPoint  = kwargs.pop("pickedPoint", None)
        self.__pickedPoint = pickedPoint
        pickingGeometry  = kwargs.pop("pickingGeometry", None)
        self.__pickingGeometry = pickingGeometry
        pickTarget  = kwargs.pop("pickTarget", None)
        self.__pickTarget = pickTarget
        sortOrder  = kwargs.pop("sortOrder", "CLOSEST")
        self.__sortOrder = sortOrder
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    def isActive(self, Active = None):
        return self.__Active
    @property
    def matchCriterion(self):
        return self.__matchCriterion
    @matchCriterion.setter
    def matchCriterion(self, value = "MATCH_ANY"):
        if 'MATCH_ANY' == value:
            pass
        elif 'MATCH_EVERY' == value:
            pass
        elif 'MATCH_ONLY_ONE' == value:
            pass
        else:
            return None
        self.__matchCriterion = [value]
    def setMatchCriterion(self, matchCriterion = "MATCH_ANY"):
        if 'MATCH_ANY' == matchCriterion:
            pass
        elif 'MATCH_EVERY' == matchCriterion:
            pass
        elif 'MATCH_ONLY_ONE' == matchCriterion:
            pass
        else:
            return None
        self.__matchCriterion = [matchCriterion]
        return self
    def addMatchCriterion(self, matchCriterion = "MATCH_ANY"):
        if 'MATCH_ANY' == matchCriterion:
            pass
        elif 'MATCH_EVERY' == matchCriterion:
            pass
        elif 'MATCH_ONLY_ONE' == matchCriterion:
            pass
        else:
            return None
        if self.__matchCriterion == None:            self.__matchCriterion =  []
        self.__matchCriterion +=  [matchCriterion]
        return self
    def removeMatchCriterion(self, matchCriterion):
        self.__matchCriterion = [x for x in self.__matchCriterion if x not in matchCriterion]
        return self.__matchCriterion
    def getMatchCriterion(self, matchCriterion = "MATCH_ANY"):
        return self.__matchCriterion
    def matchCriterion_changed(self, matchCriterion = "MATCH_ANY"):
        return self.__matchCriterion
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def objectType(self):
        return self.__objectType
    @objectType.setter
    def objectType(self, value = ["ALL"]):
        self.__objectType = [value]
    def setObjectType(self, objectType = ["ALL"]):
        self.__objectType = [objectType]
        return self
    def addObjectType(self, objectType = ["ALL"]):
        if self.__objectType == None:            self.__objectType =  []
        self.__objectType +=  [objectType]
        return self
    def removeObjectType(self, objectType):
        self.__objectType = [x for x in self.__objectType if x not in objectType]
        return self.__objectType
    def getObjectType(self, objectType = ["ALL"]):
        return self.__objectType
    def objectType_changed(self, objectType = ["ALL"]):
        return self.__objectType
    def removePickedGeometry(self, pickedGeometry):
        self.__pickedGeometry = [x for x in self.__pickedGeometry if x not in pickedGeometry]
        return self.__pickedGeometry
    def getPickedGeometry(self, pickedGeometry = None):
        return self.__pickedGeometry
    def pickedGeometry_changed(self, pickedGeometry = None):
        return self.__pickedGeometry
    def removePickedPoint(self, pickedPoint):
        self.__pickedPoint = [x for x in self.__pickedPoint if x not in pickedPoint]
        return self.__pickedPoint
    def getPickedPoint(self, pickedPoint = None):
        return self.__pickedPoint
    def pickedPoint_changed(self, pickedPoint = None):
        return self.__pickedPoint
    @property
    def pickingGeometry(self):
        return self.__pickingGeometry
    @pickingGeometry.setter
    def pickingGeometry(self, value = None):
        self.__pickingGeometry = [value]
    def setPickingGeometry(self, pickingGeometry = None):
        self.__pickingGeometry = [pickingGeometry]
        return self
    def addPickingGeometry(self, pickingGeometry = None):
        if self.__pickingGeometry == None:            self.__pickingGeometry =  []
        self.__pickingGeometry +=  [pickingGeometry]
        return self
    def removePickingGeometry(self, pickingGeometry):
        self.__pickingGeometry = [x for x in self.__pickingGeometry if x not in pickingGeometry]
        return self.__pickingGeometry
    def getPickingGeometry(self, pickingGeometry = None):
        return self.__pickingGeometry
    def pickingGeometry_changed(self, pickingGeometry = None):
        return self.__pickingGeometry
    @property
    def pickTarget(self):
        return self.__pickTarget
    @pickTarget.setter
    def pickTarget(self, value = None):
        self.__pickTarget = [value]
    def setPickTarget(self, pickTarget = None):
        self.__pickTarget = [pickTarget]
        return self
    def addPickTarget(self, pickTarget = None):
        if self.__pickTarget == None:            self.__pickTarget =  []
        self.__pickTarget +=  [pickTarget]
        return self
    def removePickTarget(self, pickTarget):
        self.__pickTarget = [x for x in self.__pickTarget if x not in pickTarget]
        return self.__pickTarget
    def getPickTarget(self, pickTarget = None):
        return self.__pickTarget
    def pickTarget_changed(self, pickTarget = None):
        return self.__pickTarget
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<PointPickSensor'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__intersectionType is not None:
            if isinstance(self.__intersectionType, six.string_types):
                str += ' intersectionType="'+self.__intersectionType+'"'
            else:
                str += ' intersectionType="'+self.__intersectionType[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__matchCriterion is not None:
            if isinstance(self.__matchCriterion, six.string_types):
                str += ' matchCriterion="'+self.__matchCriterion+'"'
            else:
                str += ' matchCriterion="'+self.__matchCriterion[0]+'"'
        if self.__objectType is not None:
            if isinstance(self.__objectType, six.string_types):
                str += ' objectType="'+self.__objectType+'"'
            else:
                str += ' objectType="'+self.__objectType[0]+'"'
        if self.__pickedPoint is not None:
            if isinstance(self.__pickedPoint, six.string_types):
                str += ' pickedPoint="'+self.__pickedPoint+'"'
            else:
                str += ' pickedPoint="'+self.__pickedPoint[0]+'"'
        if self.__sortOrder is not None:
            if isinstance(self.__sortOrder, six.string_types):
                str += ' sortOrder="'+self.__sortOrder+'"'
            else:
                str += ' sortOrder="'+self.__sortOrder[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<pickedGeometry'
        if self.__pickedGeometry is not None:
           for s in self.__pickedGeometry:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__pickedGeometry is not None:
           for s in self.__pickedGeometry:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</pickedGeometry>'
        str += '<pickingGeometry'
        if self.__pickingGeometry is not None:
           for s in self.__pickingGeometry:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__pickingGeometry is not None:
           for s in self.__pickingGeometry:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</pickingGeometry>'
        str += '<pickTarget'
        if self.__pickTarget is not None:
           for s in self.__pickTarget:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__pickTarget is not None:
           for s in self.__pickTarget:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</pickTarget>'
        str += '</PointPickSensor>'
        return str


class PointProperties(X3DAppearanceChildNode):
    def __init__(self, **kwargs):
        super(PointProperties, self).__init__(**kwargs)
        colorMode  = kwargs.pop("colorMode", "TEXTURE_AND_POINT_COLOR")
        if 'POINT_COLOR' == colorMode:
            pass
        elif 'TEXTURE_COLOR' == colorMode:
            pass
        elif 'TEXTURE_AND_POINT_COLOR' == colorMode:
            pass
        else:
            return None
        self.__colorMode = colorMode
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        pointSizeAttenuation  = kwargs.pop("pointSizeAttenuation", [1, 0, 0])
        self.__pointSizeAttenuation = pointSizeAttenuation
        pointSizeMaxValue  = kwargs.pop("pointSizeMaxValue", 1)
        if pointSizeMaxValue == None or pointSizeMaxValue  <  0:
            return None
        self.__pointSizeMaxValue = pointSizeMaxValue
        pointSizeMinValue  = kwargs.pop("pointSizeMinValue", 1)
        if pointSizeMinValue == None or pointSizeMinValue  <  0:
            return None
        self.__pointSizeMinValue = pointSizeMinValue
        pointSizeScaleFactor  = kwargs.pop("pointSizeScaleFactor", 1)
        if pointSizeScaleFactor == None or pointSizeScaleFactor  <  1:
            return None
        self.__pointSizeScaleFactor = pointSizeScaleFactor
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def colorMode(self):
        return self.__colorMode
    @colorMode.setter
    def colorMode(self, value = "TEXTURE_AND_POINT_COLOR"):
        if 'POINT_COLOR' == value:
            pass
        elif 'TEXTURE_COLOR' == value:
            pass
        elif 'TEXTURE_AND_POINT_COLOR' == value:
            pass
        else:
            return None
        self.__colorMode = [value]
    def setColorMode(self, colorMode = "TEXTURE_AND_POINT_COLOR"):
        if 'POINT_COLOR' == colorMode:
            pass
        elif 'TEXTURE_COLOR' == colorMode:
            pass
        elif 'TEXTURE_AND_POINT_COLOR' == colorMode:
            pass
        else:
            return None
        self.__colorMode = [colorMode]
        return self
    def addColorMode(self, colorMode = "TEXTURE_AND_POINT_COLOR"):
        if 'POINT_COLOR' == colorMode:
            pass
        elif 'TEXTURE_COLOR' == colorMode:
            pass
        elif 'TEXTURE_AND_POINT_COLOR' == colorMode:
            pass
        else:
            return None
        if self.__colorMode == None:            self.__colorMode =  []
        self.__colorMode +=  [colorMode]
        return self
    def removeColorMode(self, colorMode):
        self.__colorMode = [x for x in self.__colorMode if x not in colorMode]
        return self.__colorMode
    def getColorMode(self, colorMode = "TEXTURE_AND_POINT_COLOR"):
        return self.__colorMode
    def colorMode_changed(self, colorMode = "TEXTURE_AND_POINT_COLOR"):
        return self.__colorMode
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def pointSizeAttenuation(self):
        return self.__pointSizeAttenuation
    @pointSizeAttenuation.setter
    def pointSizeAttenuation(self, value = [1, 0, 0]):
        self.__pointSizeAttenuation = [value]
    def setPointSizeAttenuation(self, pointSizeAttenuation = [1, 0, 0]):
        self.__pointSizeAttenuation = [pointSizeAttenuation]
        return self
    def addPointSizeAttenuation(self, pointSizeAttenuation = [1, 0, 0]):
        if self.__pointSizeAttenuation == None:            self.__pointSizeAttenuation =  []
        self.__pointSizeAttenuation +=  [pointSizeAttenuation]
        return self
    def removePointSizeAttenuation(self, pointSizeAttenuation):
        self.__pointSizeAttenuation = [x for x in self.__pointSizeAttenuation if x not in pointSizeAttenuation]
        return self.__pointSizeAttenuation
    def getPointSizeAttenuation(self, pointSizeAttenuation = [1, 0, 0]):
        return self.__pointSizeAttenuation
    def pointSizeAttenuation_changed(self, pointSizeAttenuation = [1, 0, 0]):
        return self.__pointSizeAttenuation
    @property
    def pointSizeMaxValue(self):
        return self.__pointSizeMaxValue
    @pointSizeMaxValue.setter
    def pointSizeMaxValue(self, value = 1):
        if value == None or value  <  0:
            return None
        self.__pointSizeMaxValue = [value]
    def setPointSizeMaxValue(self, pointSizeMaxValue = 1):
        if pointSizeMaxValue == None or pointSizeMaxValue  <  0:
            return None
        self.__pointSizeMaxValue = [pointSizeMaxValue]
        return self
    def addPointSizeMaxValue(self, pointSizeMaxValue = 1):
        if pointSizeMaxValue == None or pointSizeMaxValue  <  0:
            return None
        if self.__pointSizeMaxValue == None:            self.__pointSizeMaxValue =  []
        self.__pointSizeMaxValue +=  [pointSizeMaxValue]
        return self
    def removePointSizeMaxValue(self, pointSizeMaxValue):
        self.__pointSizeMaxValue = [x for x in self.__pointSizeMaxValue if x not in pointSizeMaxValue]
        return self.__pointSizeMaxValue
    def getPointSizeMaxValue(self, pointSizeMaxValue = 1):
        return self.__pointSizeMaxValue
    def pointSizeMaxValue_changed(self, pointSizeMaxValue = 1):
        return self.__pointSizeMaxValue
    @property
    def pointSizeMinValue(self):
        return self.__pointSizeMinValue
    @pointSizeMinValue.setter
    def pointSizeMinValue(self, value = 1):
        if value == None or value  <  0:
            return None
        self.__pointSizeMinValue = [value]
    def setPointSizeMinValue(self, pointSizeMinValue = 1):
        if pointSizeMinValue == None or pointSizeMinValue  <  0:
            return None
        self.__pointSizeMinValue = [pointSizeMinValue]
        return self
    def addPointSizeMinValue(self, pointSizeMinValue = 1):
        if pointSizeMinValue == None or pointSizeMinValue  <  0:
            return None
        if self.__pointSizeMinValue == None:            self.__pointSizeMinValue =  []
        self.__pointSizeMinValue +=  [pointSizeMinValue]
        return self
    def removePointSizeMinValue(self, pointSizeMinValue):
        self.__pointSizeMinValue = [x for x in self.__pointSizeMinValue if x not in pointSizeMinValue]
        return self.__pointSizeMinValue
    def getPointSizeMinValue(self, pointSizeMinValue = 1):
        return self.__pointSizeMinValue
    def pointSizeMinValue_changed(self, pointSizeMinValue = 1):
        return self.__pointSizeMinValue
    @property
    def pointSizeScaleFactor(self):
        return self.__pointSizeScaleFactor
    @pointSizeScaleFactor.setter
    def pointSizeScaleFactor(self, value = 1):
        if value == None or value  <  1:
            return None
        self.__pointSizeScaleFactor = [value]
    def setPointSizeScaleFactor(self, pointSizeScaleFactor = 1):
        if pointSizeScaleFactor == None or pointSizeScaleFactor  <  1:
            return None
        self.__pointSizeScaleFactor = [pointSizeScaleFactor]
        return self
    def addPointSizeScaleFactor(self, pointSizeScaleFactor = 1):
        if pointSizeScaleFactor == None or pointSizeScaleFactor  <  1:
            return None
        if self.__pointSizeScaleFactor == None:            self.__pointSizeScaleFactor =  []
        self.__pointSizeScaleFactor +=  [pointSizeScaleFactor]
        return self
    def removePointSizeScaleFactor(self, pointSizeScaleFactor):
        self.__pointSizeScaleFactor = [x for x in self.__pointSizeScaleFactor if x not in pointSizeScaleFactor]
        return self.__pointSizeScaleFactor
    def getPointSizeScaleFactor(self, pointSizeScaleFactor = 1):
        return self.__pointSizeScaleFactor
    def pointSizeScaleFactor_changed(self, pointSizeScaleFactor = 1):
        return self.__pointSizeScaleFactor
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<PointProperties'
        if self.__colorMode is not None:
            if isinstance(self.__colorMode, six.string_types):
                str += ' colorMode="'+self.__colorMode+'"'
            else:
                str += ' colorMode="'+self.__colorMode[0]+'"'
        if self.__pointSizeAttenuation is not None:
            if isinstance(self.__pointSizeAttenuation, six.string_types):
                str += ' pointSizeAttenuation="'+self.__pointSizeAttenuation+'"'
            else:
                str += ' pointSizeAttenuation="'+self.__pointSizeAttenuation[0]+'"'
        if self.__pointSizeMaxValue is not None:
            if isinstance(self.__pointSizeMaxValue, six.string_types):
                str += ' pointSizeMaxValue="'+self.__pointSizeMaxValue+'"'
            else:
                str += ' pointSizeMaxValue="'+self.__pointSizeMaxValue[0]+'"'
        if self.__pointSizeMinValue is not None:
            if isinstance(self.__pointSizeMinValue, six.string_types):
                str += ' pointSizeMinValue="'+self.__pointSizeMinValue+'"'
            else:
                str += ' pointSizeMinValue="'+self.__pointSizeMinValue[0]+'"'
        if self.__pointSizeScaleFactor is not None:
            if isinstance(self.__pointSizeScaleFactor, six.string_types):
                str += ' pointSizeScaleFactor="'+self.__pointSizeScaleFactor+'"'
            else:
                str += ' pointSizeScaleFactor="'+self.__pointSizeScaleFactor[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</PointProperties>'
        return str


class PointSet(X3DGeometryNode):
    def __init__(self, **kwargs):
        super(PointSet, self).__init__(**kwargs)
        attrib  = kwargs.pop("attrib", None)
        self.__attrib = attrib
        color  = kwargs.pop("color", None)
        self.__color = color
        coord  = kwargs.pop("coord", None)
        self.__coord = coord
        fogCoord  = kwargs.pop("fogCoord", None)
        self.__fogCoord = fogCoord
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def attrib(self):
        return self.__attrib
    @attrib.setter
    def attrib(self, value = None):
        self.__attrib = [value]
    def setAttrib(self, attrib = None):
        self.__attrib = [attrib]
        return self
    def addAttrib(self, attrib = None):
        if self.__attrib == None:            self.__attrib =  []
        self.__attrib +=  [attrib]
        return self
    def removeAttrib(self, attrib):
        self.__attrib = [x for x in self.__attrib if x not in attrib]
        return self.__attrib
    def getAttrib(self, attrib = None):
        return self.__attrib
    def attrib_changed(self, attrib = None):
        return self.__attrib
    @property
    def color(self):
        return self.__color
    @color.setter
    def color(self, value = None):
        self.__color = [value]
    def setColor(self, color = None):
        self.__color = [color]
        return self
    def addColor(self, color = None):
        if self.__color == None:            self.__color =  []
        self.__color +=  [color]
        return self
    def removeColor(self, color):
        self.__color = [x for x in self.__color if x not in color]
        return self.__color
    def getColor(self, color = None):
        return self.__color
    def color_changed(self, color = None):
        return self.__color
    @property
    def coord(self):
        return self.__coord
    @coord.setter
    def coord(self, value = None):
        self.__coord = [value]
    def setCoord(self, coord = None):
        self.__coord = [coord]
        return self
    def addCoord(self, coord = None):
        if self.__coord == None:            self.__coord =  []
        self.__coord +=  [coord]
        return self
    def removeCoord(self, coord):
        self.__coord = [x for x in self.__coord if x not in coord]
        return self.__coord
    def getCoord(self, coord = None):
        return self.__coord
    def coord_changed(self, coord = None):
        return self.__coord
    @property
    def fogCoord(self):
        return self.__fogCoord
    @fogCoord.setter
    def fogCoord(self, value = None):
        self.__fogCoord = [value]
    def setFogCoord(self, fogCoord = None):
        self.__fogCoord = [fogCoord]
        return self
    def addFogCoord(self, fogCoord = None):
        if self.__fogCoord == None:            self.__fogCoord =  []
        self.__fogCoord +=  [fogCoord]
        return self
    def removeFogCoord(self, fogCoord):
        self.__fogCoord = [x for x in self.__fogCoord if x not in fogCoord]
        return self.__fogCoord
    def getFogCoord(self, fogCoord = None):
        return self.__fogCoord
    def fogCoord_changed(self, fogCoord = None):
        return self.__fogCoord
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<PointSet'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<attrib'
        if self.__attrib is not None:
           for s in self.__attrib:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__attrib is not None:
           for s in self.__attrib:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</attrib>'
        str += '<color'
        if self.__color is not None:
           for s in self.__color:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__color is not None:
           for s in self.__color:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</color>'
        str += '<coord'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</coord>'
        str += '<fogCoord'
        if self.__fogCoord is not None:
           for s in self.__fogCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__fogCoord is not None:
           for s in self.__fogCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</fogCoord>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</PointSet>'
        return str


class Polyline2D(X3DGeometryNode):
    def __init__(self, **kwargs):
        super(Polyline2D, self).__init__(**kwargs)
        lineSegments  = kwargs.pop("lineSegments", None)
        self.__lineSegments = lineSegments
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Polyline2D'
        if self.__lineSegments is not None:
            if isinstance(self.__lineSegments, six.string_types):
                str += ' lineSegments="'+self.__lineSegments+'"'
            else:
                str += ' lineSegments="'+self.__lineSegments[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</Polyline2D>'
        return str


class PolylineEmitter(X3DParticleEmitterNode):
    def __init__(self, **kwargs):
        super(PolylineEmitter, self).__init__(**kwargs)
        coord  = kwargs.pop("coord", None)
        self.__coord = coord
        coordIndex  = kwargs.pop("coordIndex", [-1])
        if coordIndex == None or len(coordIndex) <= 0 or min(coordIndex)  <  -1:
            return None
        self.__coordIndex = coordIndex
        direction  = kwargs.pop("direction", [0, 1, 0])
        if direction == None or len(direction) <= 0 or min(direction)  <  -1:
            return None
        if direction == None or len(direction) <= 0 or max(direction)  >  1:
            return None
        self.__direction = direction
        mass  = kwargs.pop("mass", 0)
        if mass == None or mass  <  0:
            return None
        self.__mass = mass
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        coordIndex  = kwargs.pop("coordIndex", None)
        if coordIndex == None or len(coordIndex) <= 0 or min(coordIndex)  <  -1:
            return None
        self.__coordIndex = coordIndex
        speed  = kwargs.pop("speed", 0)
        if speed == None or speed  <  0:
            return None
        self.__speed = speed
        surfaceArea  = kwargs.pop("surfaceArea", 0)
        if surfaceArea == None or surfaceArea  <  0:
            return None
        self.__surfaceArea = surfaceArea
        variation  = kwargs.pop("variation", 0.25)
        if variation == None or variation  <  0:
            return None
        self.__variation = variation
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def coord(self):
        return self.__coord
    @coord.setter
    def coord(self, value = None):
        self.__coord = [value]
    def setCoord(self, coord = None):
        self.__coord = [coord]
        return self
    def addCoord(self, coord = None):
        if self.__coord == None:            self.__coord =  []
        self.__coord +=  [coord]
        return self
    def removeCoord(self, coord):
        self.__coord = [x for x in self.__coord if x not in coord]
        return self.__coord
    def getCoord(self, coord = None):
        return self.__coord
    def coord_changed(self, coord = None):
        return self.__coord
    @property
    def direction(self):
        return self.__direction
    @direction.setter
    def direction(self, value = [0, 1, 0]):
        if value == None or len(value) <= 0 or min(value)  <  -1:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__direction = [value]
    def setDirection(self, direction = [0, 1, 0]):
        if direction == None or len(direction) <= 0 or min(direction)  <  -1:
            return None
        if direction == None or len(direction) <= 0 or max(direction)  >  1:
            return None
        self.__direction = [direction]
        return self
    def addDirection(self, direction = [0, 1, 0]):
        if direction == None or len(direction) <= 0 or min(direction)  <  -1:
            return None
        if direction == None or len(direction) <= 0 or max(direction)  >  1:
            return None
        if self.__direction == None:            self.__direction =  []
        self.__direction +=  [direction]
        return self
    def removeDirection(self, direction):
        self.__direction = [x for x in self.__direction if x not in direction]
        return self.__direction
    def getDirection(self, direction = [0, 1, 0]):
        return self.__direction
    def direction_changed(self, direction = [0, 1, 0]):
        return self.__direction
    @property
    def mass(self):
        return self.__mass
    @mass.setter
    def mass(self, value = 0):
        if value == None or value  <  0:
            return None
        self.__mass = [value]
    def setMass(self, mass = 0):
        if mass == None or mass  <  0:
            return None
        self.__mass = [mass]
        return self
    def addMass(self, mass = 0):
        if mass == None or mass  <  0:
            return None
        if self.__mass == None:            self.__mass =  []
        self.__mass +=  [mass]
        return self
    def removeMass(self, mass):
        self.__mass = [x for x in self.__mass if x not in mass]
        return self.__mass
    def getMass(self, mass = 0):
        return self.__mass
    def mass_changed(self, mass = 0):
        return self.__mass
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def coordIndex(self):
        return self.__coordIndex
    @coordIndex.setter
    def coordIndex(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  -1:
            return None
        self.__coordIndex = [value]
    def set_coordIndex(self, coordIndex = None):
        if coordIndex == None or len(coordIndex) <= 0 or min(coordIndex)  <  -1:
            return None
        self.__coordIndex = [coordIndex]
        return self
    @property
    def speed(self):
        return self.__speed
    @speed.setter
    def speed(self, value = 0):
        if value == None or value  <  0:
            return None
        self.__speed = [value]
    def setSpeed(self, speed = 0):
        if speed == None or speed  <  0:
            return None
        self.__speed = [speed]
        return self
    def addSpeed(self, speed = 0):
        if speed == None or speed  <  0:
            return None
        if self.__speed == None:            self.__speed =  []
        self.__speed +=  [speed]
        return self
    def removeSpeed(self, speed):
        self.__speed = [x for x in self.__speed if x not in speed]
        return self.__speed
    def getSpeed(self, speed = 0):
        return self.__speed
    def speed_changed(self, speed = 0):
        return self.__speed
    @property
    def variation(self):
        return self.__variation
    @variation.setter
    def variation(self, value = 0.25):
        if value == None or value  <  0:
            return None
        self.__variation = [value]
    def setVariation(self, variation = 0.25):
        if variation == None or variation  <  0:
            return None
        self.__variation = [variation]
        return self
    def addVariation(self, variation = 0.25):
        if variation == None or variation  <  0:
            return None
        if self.__variation == None:            self.__variation =  []
        self.__variation +=  [variation]
        return self
    def removeVariation(self, variation):
        self.__variation = [x for x in self.__variation if x not in variation]
        return self.__variation
    def getVariation(self, variation = 0.25):
        return self.__variation
    def variation_changed(self, variation = 0.25):
        return self.__variation
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<PolylineEmitter'
        if self.__coordIndex is not None:
            if isinstance(self.__coordIndex, six.string_types):
                str += ' coordIndex="'+self.__coordIndex+'"'
            else:
                str += ' coordIndex="'+self.__coordIndex[0]+'"'
        if self.__direction is not None:
            if isinstance(self.__direction, six.string_types):
                str += ' direction="'+self.__direction+'"'
            else:
                str += ' direction="'+self.__direction[0]+'"'
        if self.__mass is not None:
            if isinstance(self.__mass, six.string_types):
                str += ' mass="'+self.__mass+'"'
            else:
                str += ' mass="'+self.__mass[0]+'"'
        if self.__coordIndex is not None:
            if isinstance(self.__coordIndex, six.string_types):
                str += ' coordIndex="'+self.__coordIndex+'"'
            else:
                str += ' coordIndex="'+self.__coordIndex[0]+'"'
        if self.__speed is not None:
            if isinstance(self.__speed, six.string_types):
                str += ' speed="'+self.__speed+'"'
            else:
                str += ' speed="'+self.__speed[0]+'"'
        if self.__surfaceArea is not None:
            if isinstance(self.__surfaceArea, six.string_types):
                str += ' surfaceArea="'+self.__surfaceArea+'"'
            else:
                str += ' surfaceArea="'+self.__surfaceArea[0]+'"'
        if self.__variation is not None:
            if isinstance(self.__variation, six.string_types):
                str += ' variation="'+self.__variation+'"'
            else:
                str += ' variation="'+self.__variation[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<coord'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</coord>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</PolylineEmitter>'
        return str


class Polypoint2D(X3DGeometryNode):
    def __init__(self, **kwargs):
        super(Polypoint2D, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        point  = kwargs.pop("point", None)
        self.__point = point
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def point(self):
        return self.__point
    @point.setter
    def point(self, value = None):
        self.__point = [value]
    def setPoint(self, point = None):
        self.__point = [point]
        return self
    def addPoint(self, point = None):
        if self.__point == None:            self.__point =  []
        self.__point +=  [point]
        return self
    def removePoint(self, point):
        self.__point = [x for x in self.__point if x not in point]
        return self.__point
    def getPoint(self, point = None):
        return self.__point
    def point_changed(self, point = None):
        return self.__point
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Polypoint2D'
        if self.__point is not None:
            if isinstance(self.__point, six.string_types):
                str += ' point="'+self.__point+'"'
            else:
                str += ' point="'+self.__point[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</Polypoint2D>'
        return str


class PositionChaser(X3DChaserNode):
    def __init__(self, **kwargs):
        super(PositionChaser, self).__init__(**kwargs)
        duration  = kwargs.pop("duration", 1)
        if duration == None or duration  <  0:
            return None
        self.__duration = duration
        initialDestination  = kwargs.pop("initialDestination", [0, 0, 0])
        self.__initialDestination = initialDestination
        initialValue  = kwargs.pop("initialValue", [0, 0, 0])
        self.__initialValue = initialValue
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        destination  = kwargs.pop("destination", None)
        self.__destination = destination
        value  = kwargs.pop("value", None)
        self.__value = value
        value_changed  = kwargs.pop("value_changed", None)
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def isActive(self, Active = None):
        return self.__Active
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def destination(self):
        return self.__destination
    @destination.setter
    def destination(self, value = None):
        self.__destination = [value]
    def set_destination(self, destination = None):
        self.__destination = [destination]
        return self
    @property
    def value(self):
        return self.__value
    @value.setter
    def value(self, value = None):
        self.__value = [value]
    def set_value(self, value = None):
        self.__value = [value]
        return self
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<PositionChaser'
        if self.__duration is not None:
            if isinstance(self.__duration, six.string_types):
                str += ' duration="'+self.__duration+'"'
            else:
                str += ' duration="'+self.__duration[0]+'"'
        if self.__initialDestination is not None:
            if isinstance(self.__initialDestination, six.string_types):
                str += ' initialDestination="'+self.__initialDestination+'"'
            else:
                str += ' initialDestination="'+self.__initialDestination[0]+'"'
        if self.__initialValue is not None:
            if isinstance(self.__initialValue, six.string_types):
                str += ' initialValue="'+self.__initialValue+'"'
            else:
                str += ' initialValue="'+self.__initialValue[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__destination is not None:
            if isinstance(self.__destination, six.string_types):
                str += ' destination="'+self.__destination+'"'
            else:
                str += ' destination="'+self.__destination[0]+'"'
        if self.__value is not None:
            if isinstance(self.__value, six.string_types):
                str += ' value="'+self.__value+'"'
            else:
                str += ' value="'+self.__value[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</PositionChaser>'
        return str


class PositionChaser2D(X3DChaserNode):
    def __init__(self, **kwargs):
        super(PositionChaser2D, self).__init__(**kwargs)
        duration  = kwargs.pop("duration", 1)
        if duration == None or duration  <  0:
            return None
        self.__duration = duration
        initialDestination  = kwargs.pop("initialDestination", [0, 0])
        self.__initialDestination = initialDestination
        initialValue  = kwargs.pop("initialValue", [0, 0])
        self.__initialValue = initialValue
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        destination  = kwargs.pop("destination", None)
        self.__destination = destination
        value  = kwargs.pop("value", None)
        self.__value = value
        value_changed  = kwargs.pop("value_changed", None)
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def isActive(self, Active = None):
        return self.__Active
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def destination(self):
        return self.__destination
    @destination.setter
    def destination(self, value = None):
        self.__destination = [value]
    def set_destination(self, destination = None):
        self.__destination = [destination]
        return self
    @property
    def value(self):
        return self.__value
    @value.setter
    def value(self, value = None):
        self.__value = [value]
    def set_value(self, value = None):
        self.__value = [value]
        return self
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<PositionChaser2D'
        if self.__duration is not None:
            if isinstance(self.__duration, six.string_types):
                str += ' duration="'+self.__duration+'"'
            else:
                str += ' duration="'+self.__duration[0]+'"'
        if self.__initialDestination is not None:
            if isinstance(self.__initialDestination, six.string_types):
                str += ' initialDestination="'+self.__initialDestination+'"'
            else:
                str += ' initialDestination="'+self.__initialDestination[0]+'"'
        if self.__initialValue is not None:
            if isinstance(self.__initialValue, six.string_types):
                str += ' initialValue="'+self.__initialValue+'"'
            else:
                str += ' initialValue="'+self.__initialValue[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__destination is not None:
            if isinstance(self.__destination, six.string_types):
                str += ' destination="'+self.__destination+'"'
            else:
                str += ' destination="'+self.__destination[0]+'"'
        if self.__value is not None:
            if isinstance(self.__value, six.string_types):
                str += ' value="'+self.__value+'"'
            else:
                str += ' value="'+self.__value[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</PositionChaser2D>'
        return str


class PositionDamper(X3DDamperNode):
    def __init__(self, **kwargs):
        super(PositionDamper, self).__init__(**kwargs)
        initialDestination  = kwargs.pop("initialDestination", [0, 0, 0])
        self.__initialDestination = initialDestination
        initialValue  = kwargs.pop("initialValue", [0, 0, 0])
        self.__initialValue = initialValue
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        order  = kwargs.pop("order", 3)
        if order == None or order  <  0:
            return None
        if order == None or order  >  5:
            return None
        self.__order = order
        destination  = kwargs.pop("destination", None)
        self.__destination = destination
        value  = kwargs.pop("value", None)
        self.__value = value
        tau  = kwargs.pop("tau", 0.3)
        if tau == None or tau  <  0:
            return None
        self.__tau = tau
        tolerance  = kwargs.pop("tolerance", -1)
        self.__tolerance = tolerance
        value_changed  = kwargs.pop("value_changed", None)
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def isActive(self, Active = None):
        return self.__Active
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def destination(self):
        return self.__destination
    @destination.setter
    def destination(self, value = None):
        self.__destination = [value]
    def set_destination(self, destination = None):
        self.__destination = [destination]
        return self
    @property
    def value(self):
        return self.__value
    @value.setter
    def value(self, value = None):
        self.__value = [value]
    def set_value(self, value = None):
        self.__value = [value]
        return self
    @property
    def tau(self):
        return self.__tau
    @tau.setter
    def tau(self, value = 0.3):
        if value == None or value  <  0:
            return None
        self.__tau = [value]
    def setTau(self, tau = 0.3):
        if tau == None or tau  <  0:
            return None
        self.__tau = [tau]
        return self
    def addTau(self, tau = 0.3):
        if tau == None or tau  <  0:
            return None
        if self.__tau == None:            self.__tau =  []
        self.__tau +=  [tau]
        return self
    def removeTau(self, tau):
        self.__tau = [x for x in self.__tau if x not in tau]
        return self.__tau
    def getTau(self, tau = 0.3):
        return self.__tau
    def tau_changed(self, tau = 0.3):
        return self.__tau
    @property
    def tolerance(self):
        return self.__tolerance
    @tolerance.setter
    def tolerance(self, value = -1):
        self.__tolerance = [value]
    def setTolerance(self, tolerance = -1):
        self.__tolerance = [tolerance]
        return self
    def addTolerance(self, tolerance = -1):
        if self.__tolerance == None:            self.__tolerance =  []
        self.__tolerance +=  [tolerance]
        return self
    def removeTolerance(self, tolerance):
        self.__tolerance = [x for x in self.__tolerance if x not in tolerance]
        return self.__tolerance
    def getTolerance(self, tolerance = -1):
        return self.__tolerance
    def tolerance_changed(self, tolerance = -1):
        return self.__tolerance
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<PositionDamper'
        if self.__initialDestination is not None:
            if isinstance(self.__initialDestination, six.string_types):
                str += ' initialDestination="'+self.__initialDestination+'"'
            else:
                str += ' initialDestination="'+self.__initialDestination[0]+'"'
        if self.__initialValue is not None:
            if isinstance(self.__initialValue, six.string_types):
                str += ' initialValue="'+self.__initialValue+'"'
            else:
                str += ' initialValue="'+self.__initialValue[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__order is not None:
            if isinstance(self.__order, six.string_types):
                str += ' order="'+self.__order+'"'
            else:
                str += ' order="'+self.__order[0]+'"'
        if self.__destination is not None:
            if isinstance(self.__destination, six.string_types):
                str += ' destination="'+self.__destination+'"'
            else:
                str += ' destination="'+self.__destination[0]+'"'
        if self.__value is not None:
            if isinstance(self.__value, six.string_types):
                str += ' value="'+self.__value+'"'
            else:
                str += ' value="'+self.__value[0]+'"'
        if self.__tau is not None:
            if isinstance(self.__tau, six.string_types):
                str += ' tau="'+self.__tau+'"'
            else:
                str += ' tau="'+self.__tau[0]+'"'
        if self.__tolerance is not None:
            if isinstance(self.__tolerance, six.string_types):
                str += ' tolerance="'+self.__tolerance+'"'
            else:
                str += ' tolerance="'+self.__tolerance[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</PositionDamper>'
        return str


class PositionDamper2D(X3DDamperNode):
    def __init__(self, **kwargs):
        super(PositionDamper2D, self).__init__(**kwargs)
        initialDestination  = kwargs.pop("initialDestination", [0, 0])
        self.__initialDestination = initialDestination
        initialValue  = kwargs.pop("initialValue", [0, 0])
        self.__initialValue = initialValue
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        order  = kwargs.pop("order", 3)
        if order == None or order  <  0:
            return None
        if order == None or order  >  5:
            return None
        self.__order = order
        destination  = kwargs.pop("destination", None)
        self.__destination = destination
        value  = kwargs.pop("value", None)
        self.__value = value
        tau  = kwargs.pop("tau", 0.3)
        if tau == None or tau  <  0:
            return None
        self.__tau = tau
        tolerance  = kwargs.pop("tolerance", -1)
        self.__tolerance = tolerance
        value_changed  = kwargs.pop("value_changed", None)
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def isActive(self, Active = None):
        return self.__Active
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def destination(self):
        return self.__destination
    @destination.setter
    def destination(self, value = None):
        self.__destination = [value]
    def set_destination(self, destination = None):
        self.__destination = [destination]
        return self
    @property
    def value(self):
        return self.__value
    @value.setter
    def value(self, value = None):
        self.__value = [value]
    def set_value(self, value = None):
        self.__value = [value]
        return self
    @property
    def tau(self):
        return self.__tau
    @tau.setter
    def tau(self, value = 0.3):
        if value == None or value  <  0:
            return None
        self.__tau = [value]
    def setTau(self, tau = 0.3):
        if tau == None or tau  <  0:
            return None
        self.__tau = [tau]
        return self
    def addTau(self, tau = 0.3):
        if tau == None or tau  <  0:
            return None
        if self.__tau == None:            self.__tau =  []
        self.__tau +=  [tau]
        return self
    def removeTau(self, tau):
        self.__tau = [x for x in self.__tau if x not in tau]
        return self.__tau
    def getTau(self, tau = 0.3):
        return self.__tau
    def tau_changed(self, tau = 0.3):
        return self.__tau
    @property
    def tolerance(self):
        return self.__tolerance
    @tolerance.setter
    def tolerance(self, value = -1):
        self.__tolerance = [value]
    def setTolerance(self, tolerance = -1):
        self.__tolerance = [tolerance]
        return self
    def addTolerance(self, tolerance = -1):
        if self.__tolerance == None:            self.__tolerance =  []
        self.__tolerance +=  [tolerance]
        return self
    def removeTolerance(self, tolerance):
        self.__tolerance = [x for x in self.__tolerance if x not in tolerance]
        return self.__tolerance
    def getTolerance(self, tolerance = -1):
        return self.__tolerance
    def tolerance_changed(self, tolerance = -1):
        return self.__tolerance
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<PositionDamper2D'
        if self.__initialDestination is not None:
            if isinstance(self.__initialDestination, six.string_types):
                str += ' initialDestination="'+self.__initialDestination+'"'
            else:
                str += ' initialDestination="'+self.__initialDestination[0]+'"'
        if self.__initialValue is not None:
            if isinstance(self.__initialValue, six.string_types):
                str += ' initialValue="'+self.__initialValue+'"'
            else:
                str += ' initialValue="'+self.__initialValue[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__order is not None:
            if isinstance(self.__order, six.string_types):
                str += ' order="'+self.__order+'"'
            else:
                str += ' order="'+self.__order[0]+'"'
        if self.__destination is not None:
            if isinstance(self.__destination, six.string_types):
                str += ' destination="'+self.__destination+'"'
            else:
                str += ' destination="'+self.__destination[0]+'"'
        if self.__value is not None:
            if isinstance(self.__value, six.string_types):
                str += ' value="'+self.__value+'"'
            else:
                str += ' value="'+self.__value[0]+'"'
        if self.__tau is not None:
            if isinstance(self.__tau, six.string_types):
                str += ' tau="'+self.__tau+'"'
            else:
                str += ' tau="'+self.__tau[0]+'"'
        if self.__tolerance is not None:
            if isinstance(self.__tolerance, six.string_types):
                str += ' tolerance="'+self.__tolerance+'"'
            else:
                str += ' tolerance="'+self.__tolerance[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</PositionDamper2D>'
        return str


class PositionInterpolator(X3DInterpolatorNode):
    def __init__(self, **kwargs):
        super(PositionInterpolator, self).__init__(**kwargs)
        key  = kwargs.pop("key", None)
        self.__key = key
        keyValue  = kwargs.pop("keyValue", None)
        self.__keyValue = keyValue
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        fraction  = kwargs.pop("fraction", None)
        self.__fraction = fraction
        value_changed  = kwargs.pop("value_changed", None)
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def key(self):
        return self.__key
    @key.setter
    def key(self, value = None):
        self.__key = [value]
    def setKey(self, key = None):
        self.__key = [key]
        return self
    def addKey(self, key = None):
        if self.__key == None:            self.__key =  []
        self.__key +=  [key]
        return self
    def removeKey(self, key):
        self.__key = [x for x in self.__key if x not in key]
        return self.__key
    def getKey(self, key = None):
        return self.__key
    def key_changed(self, key = None):
        return self.__key
    @property
    def keyValue(self):
        return self.__keyValue
    @keyValue.setter
    def keyValue(self, value = None):
        self.__keyValue = [value]
    def setKeyValue(self, keyValue = None):
        self.__keyValue = [keyValue]
        return self
    def addKeyValue(self, keyValue = None):
        if self.__keyValue == None:            self.__keyValue =  []
        self.__keyValue +=  [keyValue]
        return self
    def removeKeyValue(self, keyValue):
        self.__keyValue = [x for x in self.__keyValue if x not in keyValue]
        return self.__keyValue
    def getKeyValue(self, keyValue = None):
        return self.__keyValue
    def keyValue_changed(self, keyValue = None):
        return self.__keyValue
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def fraction(self):
        return self.__fraction
    @fraction.setter
    def fraction(self, value = None):
        self.__fraction = [value]
    def set_fraction(self, fraction = None):
        self.__fraction = [fraction]
        return self
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    @property
    def IS(self):
        return self.__IS
    @IS.setter
    def IS(self, value = None):
        self.__IS = [value]
    def setIS(self, IS = None):
        self.__IS = [IS]
        return self
    def addIS(self, IS = None):
        if self.__IS == None:            self.__IS =  []
        self.__IS +=  [IS]
        return self
    def removeIS(self, IS):
        self.__IS = [x for x in self.__IS if x not in IS]
        return self.__IS
    def getIS(self, IS = None):
        return self.__IS
    def IS_changed(self, IS = None):
        return self.__IS
    def toXML(self):
        str = ''
        str += '<PositionInterpolator'
        if self.__key is not None:
            if isinstance(self.__key, six.string_types):
                str += ' key="'+self.__key+'"'
            else:
                str += ' key="'+self.__key[0]+'"'
        if self.__keyValue is not None:
            if isinstance(self.__keyValue, six.string_types):
                str += ' keyValue="'+self.__keyValue+'"'
            else:
                str += ' keyValue="'+self.__keyValue[0]+'"'
        if self.__fraction is not None:
            if isinstance(self.__fraction, six.string_types):
                str += ' fraction="'+self.__fraction+'"'
            else:
                str += ' fraction="'+self.__fraction[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</PositionInterpolator>'
        return str


class PositionInterpolator2D(X3DInterpolatorNode):
    def __init__(self, **kwargs):
        super(PositionInterpolator2D, self).__init__(**kwargs)
        key  = kwargs.pop("key", None)
        self.__key = key
        keyValue  = kwargs.pop("keyValue", None)
        self.__keyValue = keyValue
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        fraction  = kwargs.pop("fraction", None)
        self.__fraction = fraction
        value_changed  = kwargs.pop("value_changed", None)
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def key(self):
        return self.__key
    @key.setter
    def key(self, value = None):
        self.__key = [value]
    def setKey(self, key = None):
        self.__key = [key]
        return self
    def addKey(self, key = None):
        if self.__key == None:            self.__key =  []
        self.__key +=  [key]
        return self
    def removeKey(self, key):
        self.__key = [x for x in self.__key if x not in key]
        return self.__key
    def getKey(self, key = None):
        return self.__key
    def key_changed(self, key = None):
        return self.__key
    @property
    def keyValue(self):
        return self.__keyValue
    @keyValue.setter
    def keyValue(self, value = None):
        self.__keyValue = [value]
    def setKeyValue(self, keyValue = None):
        self.__keyValue = [keyValue]
        return self
    def addKeyValue(self, keyValue = None):
        if self.__keyValue == None:            self.__keyValue =  []
        self.__keyValue +=  [keyValue]
        return self
    def removeKeyValue(self, keyValue):
        self.__keyValue = [x for x in self.__keyValue if x not in keyValue]
        return self.__keyValue
    def getKeyValue(self, keyValue = None):
        return self.__keyValue
    def keyValue_changed(self, keyValue = None):
        return self.__keyValue
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def fraction(self):
        return self.__fraction
    @fraction.setter
    def fraction(self, value = None):
        self.__fraction = [value]
    def set_fraction(self, fraction = None):
        self.__fraction = [fraction]
        return self
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<PositionInterpolator2D'
        if self.__key is not None:
            if isinstance(self.__key, six.string_types):
                str += ' key="'+self.__key+'"'
            else:
                str += ' key="'+self.__key[0]+'"'
        if self.__keyValue is not None:
            if isinstance(self.__keyValue, six.string_types):
                str += ' keyValue="'+self.__keyValue+'"'
            else:
                str += ' keyValue="'+self.__keyValue[0]+'"'
        if self.__fraction is not None:
            if isinstance(self.__fraction, six.string_types):
                str += ' fraction="'+self.__fraction+'"'
            else:
                str += ' fraction="'+self.__fraction[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</PositionInterpolator2D>'
        return str


class PrimitivePickSensor(X3DPickSensorNode):
    def __init__(self, **kwargs):
        super(PrimitivePickSensor, self).__init__(**kwargs)
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        intersectionType  = kwargs.pop("intersectionType", "BOUNDS")
        self.__intersectionType = intersectionType
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        matchCriterion  = kwargs.pop("matchCriterion", "MATCH_ANY")
        if 'MATCH_ANY' == matchCriterion:
            pass
        elif 'MATCH_EVERY' == matchCriterion:
            pass
        elif 'MATCH_ONLY_ONE' == matchCriterion:
            pass
        else:
            return None
        self.__matchCriterion = matchCriterion
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        objectType  = kwargs.pop("objectType", ["ALL"])
        self.__objectType = objectType
        pickedGeometry  = kwargs.pop("pickedGeometry", None)
        self.__pickedGeometry = pickedGeometry
        pickingGeometry  = kwargs.pop("pickingGeometry", None)
        self.__pickingGeometry = pickingGeometry
        pickTarget  = kwargs.pop("pickTarget", None)
        self.__pickTarget = pickTarget
        sortOrder  = kwargs.pop("sortOrder", "CLOSEST")
        self.__sortOrder = sortOrder
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    def isActive(self, Active = None):
        return self.__Active
    @property
    def matchCriterion(self):
        return self.__matchCriterion
    @matchCriterion.setter
    def matchCriterion(self, value = "MATCH_ANY"):
        if 'MATCH_ANY' == value:
            pass
        elif 'MATCH_EVERY' == value:
            pass
        elif 'MATCH_ONLY_ONE' == value:
            pass
        else:
            return None
        self.__matchCriterion = [value]
    def setMatchCriterion(self, matchCriterion = "MATCH_ANY"):
        if 'MATCH_ANY' == matchCriterion:
            pass
        elif 'MATCH_EVERY' == matchCriterion:
            pass
        elif 'MATCH_ONLY_ONE' == matchCriterion:
            pass
        else:
            return None
        self.__matchCriterion = [matchCriterion]
        return self
    def addMatchCriterion(self, matchCriterion = "MATCH_ANY"):
        if 'MATCH_ANY' == matchCriterion:
            pass
        elif 'MATCH_EVERY' == matchCriterion:
            pass
        elif 'MATCH_ONLY_ONE' == matchCriterion:
            pass
        else:
            return None
        if self.__matchCriterion == None:            self.__matchCriterion =  []
        self.__matchCriterion +=  [matchCriterion]
        return self
    def removeMatchCriterion(self, matchCriterion):
        self.__matchCriterion = [x for x in self.__matchCriterion if x not in matchCriterion]
        return self.__matchCriterion
    def getMatchCriterion(self, matchCriterion = "MATCH_ANY"):
        return self.__matchCriterion
    def matchCriterion_changed(self, matchCriterion = "MATCH_ANY"):
        return self.__matchCriterion
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def objectType(self):
        return self.__objectType
    @objectType.setter
    def objectType(self, value = ["ALL"]):
        self.__objectType = [value]
    def setObjectType(self, objectType = ["ALL"]):
        self.__objectType = [objectType]
        return self
    def addObjectType(self, objectType = ["ALL"]):
        if self.__objectType == None:            self.__objectType =  []
        self.__objectType +=  [objectType]
        return self
    def removeObjectType(self, objectType):
        self.__objectType = [x for x in self.__objectType if x not in objectType]
        return self.__objectType
    def getObjectType(self, objectType = ["ALL"]):
        return self.__objectType
    def objectType_changed(self, objectType = ["ALL"]):
        return self.__objectType
    def removePickedGeometry(self, pickedGeometry):
        self.__pickedGeometry = [x for x in self.__pickedGeometry if x not in pickedGeometry]
        return self.__pickedGeometry
    def getPickedGeometry(self, pickedGeometry = None):
        return self.__pickedGeometry
    def pickedGeometry_changed(self, pickedGeometry = None):
        return self.__pickedGeometry
    @property
    def pickingGeometry(self):
        return self.__pickingGeometry
    @pickingGeometry.setter
    def pickingGeometry(self, value = None):
        self.__pickingGeometry = [value]
    def setPickingGeometry(self, pickingGeometry = None):
        self.__pickingGeometry = [pickingGeometry]
        return self
    def addPickingGeometry(self, pickingGeometry = None):
        if self.__pickingGeometry == None:            self.__pickingGeometry =  []
        self.__pickingGeometry +=  [pickingGeometry]
        return self
    def removePickingGeometry(self, pickingGeometry):
        self.__pickingGeometry = [x for x in self.__pickingGeometry if x not in pickingGeometry]
        return self.__pickingGeometry
    def getPickingGeometry(self, pickingGeometry = None):
        return self.__pickingGeometry
    def pickingGeometry_changed(self, pickingGeometry = None):
        return self.__pickingGeometry
    @property
    def pickTarget(self):
        return self.__pickTarget
    @pickTarget.setter
    def pickTarget(self, value = None):
        self.__pickTarget = [value]
    def setPickTarget(self, pickTarget = None):
        self.__pickTarget = [pickTarget]
        return self
    def addPickTarget(self, pickTarget = None):
        if self.__pickTarget == None:            self.__pickTarget =  []
        self.__pickTarget +=  [pickTarget]
        return self
    def removePickTarget(self, pickTarget):
        self.__pickTarget = [x for x in self.__pickTarget if x not in pickTarget]
        return self.__pickTarget
    def getPickTarget(self, pickTarget = None):
        return self.__pickTarget
    def pickTarget_changed(self, pickTarget = None):
        return self.__pickTarget
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<PrimitivePickSensor'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__intersectionType is not None:
            if isinstance(self.__intersectionType, six.string_types):
                str += ' intersectionType="'+self.__intersectionType+'"'
            else:
                str += ' intersectionType="'+self.__intersectionType[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__matchCriterion is not None:
            if isinstance(self.__matchCriterion, six.string_types):
                str += ' matchCriterion="'+self.__matchCriterion+'"'
            else:
                str += ' matchCriterion="'+self.__matchCriterion[0]+'"'
        if self.__objectType is not None:
            if isinstance(self.__objectType, six.string_types):
                str += ' objectType="'+self.__objectType+'"'
            else:
                str += ' objectType="'+self.__objectType[0]+'"'
        if self.__sortOrder is not None:
            if isinstance(self.__sortOrder, six.string_types):
                str += ' sortOrder="'+self.__sortOrder+'"'
            else:
                str += ' sortOrder="'+self.__sortOrder[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<pickedGeometry'
        if self.__pickedGeometry is not None:
           for s in self.__pickedGeometry:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__pickedGeometry is not None:
           for s in self.__pickedGeometry:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</pickedGeometry>'
        str += '<pickingGeometry'
        if self.__pickingGeometry is not None:
           for s in self.__pickingGeometry:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__pickingGeometry is not None:
           for s in self.__pickingGeometry:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</pickingGeometry>'
        str += '<pickTarget'
        if self.__pickTarget is not None:
           for s in self.__pickTarget:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__pickTarget is not None:
           for s in self.__pickTarget:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</pickTarget>'
        str += '</PrimitivePickSensor>'
        return str


class ProgramShader(X3DShaderNode):
    def __init__(self, **kwargs):
        super(ProgramShader, self).__init__(**kwargs)
        activate  = kwargs.pop("activate", None)
        self.__activate = activate
        Selected  = kwargs.pop("Selected", None)
        self.__Selected = Selected
        Valid  = kwargs.pop("Valid", None)
        self.__Valid = Valid
        language  = kwargs.pop("language", None)
        self.__language = language
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        programs  = kwargs.pop("programs", None)
        self.__programs = programs
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def activate(self):
        return self.__activate
    @activate.setter
    def activate(self, value = None):
        self.__activate = [value]
    def setActivate(self, activate = None):
        self.__activate = [activate]
        return self
    def addActivate(self, activate = None):
        if self.__activate == None:            self.__activate =  []
        self.__activate +=  [activate]
        return self
    def isSelected(self, Selected = None):
        return self.__Selected
    def isValid(self, Valid = None):
        return self.__Valid
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def programs(self):
        return self.__programs
    @programs.setter
    def programs(self, value = None):
        self.__programs = [value]
    def setPrograms(self, programs = None):
        self.__programs = [programs]
        return self
    def addPrograms(self, programs = None):
        if self.__programs == None:            self.__programs =  []
        self.__programs +=  [programs]
        return self
    def removePrograms(self, programs):
        self.__programs = [x for x in self.__programs if x not in programs]
        return self.__programs
    def getPrograms(self, programs = None):
        return self.__programs
    def programs_changed(self, programs = None):
        return self.__programs
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ProgramShader'
        if self.__activate is not None:
            if isinstance(self.__activate, six.string_types):
                str += ' activate="'+self.__activate+'"'
            else:
                str += ' activate="'+self.__activate[0]+'"'
        if self.__Selected is not None:
            if isinstance(self.__Selected, six.string_types):
                str += ' Selected="'+self.__Selected+'"'
            else:
                str += ' Selected="'+self.__Selected[0]+'"'
        if self.__Valid is not None:
            if isinstance(self.__Valid, six.string_types):
                str += ' Valid="'+self.__Valid+'"'
            else:
                str += ' Valid="'+self.__Valid[0]+'"'
        if self.__language is not None:
            if isinstance(self.__language, six.string_types):
                str += ' language="'+self.__language+'"'
            else:
                str += ' language="'+self.__language[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<programs'
        if self.__programs is not None:
           for s in self.__programs:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__programs is not None:
           for s in self.__programs:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</programs>'
        str += '</ProgramShader>'
        return str


class ProjectionVolumeStyle(X3DVolumeRenderStyleNode):
    def __init__(self, **kwargs):
        super(ProjectionVolumeStyle, self).__init__(**kwargs)
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        intensityThreshold  = kwargs.pop("intensityThreshold", 0)
        if intensityThreshold == None or intensityThreshold  <  0:
            return None
        if intensityThreshold == None or intensityThreshold  >  1:
            return None
        self.__intensityThreshold = intensityThreshold
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        type  = kwargs.pop("type", "MAX")
        if 'MAX' == type:
            pass
        elif 'MIN' == type:
            pass
        elif 'AVERAGE' == type:
            pass
        else:
            return None
        self.__type = type
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def intensityThreshold(self):
        return self.__intensityThreshold
    @intensityThreshold.setter
    def intensityThreshold(self, value = 0):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__intensityThreshold = [value]
    def setIntensityThreshold(self, intensityThreshold = 0):
        if intensityThreshold == None or intensityThreshold  <  0:
            return None
        if intensityThreshold == None or intensityThreshold  >  1:
            return None
        self.__intensityThreshold = [intensityThreshold]
        return self
    def addIntensityThreshold(self, intensityThreshold = 0):
        if intensityThreshold == None or intensityThreshold  <  0:
            return None
        if intensityThreshold == None or intensityThreshold  >  1:
            return None
        if self.__intensityThreshold == None:            self.__intensityThreshold =  []
        self.__intensityThreshold +=  [intensityThreshold]
        return self
    def removeIntensityThreshold(self, intensityThreshold):
        self.__intensityThreshold = [x for x in self.__intensityThreshold if x not in intensityThreshold]
        return self.__intensityThreshold
    def getIntensityThreshold(self, intensityThreshold = 0):
        return self.__intensityThreshold
    def intensityThreshold_changed(self, intensityThreshold = 0):
        return self.__intensityThreshold
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def type(self):
        return self.__type
    @type.setter
    def type(self, value = "MAX"):
        if 'MAX' == value:
            pass
        elif 'MIN' == value:
            pass
        elif 'AVERAGE' == value:
            pass
        else:
            return None
        self.__type = [value]
    def setType(self, type = "MAX"):
        if 'MAX' == type:
            pass
        elif 'MIN' == type:
            pass
        elif 'AVERAGE' == type:
            pass
        else:
            return None
        self.__type = [type]
        return self
    def addType(self, type = "MAX"):
        if 'MAX' == type:
            pass
        elif 'MIN' == type:
            pass
        elif 'AVERAGE' == type:
            pass
        else:
            return None
        if self.__type == None:            self.__type =  []
        self.__type +=  [type]
        return self
    def removeType(self, type):
        self.__type = [x for x in self.__type if x not in type]
        return self.__type
    def getType(self, type = "MAX"):
        return self.__type
    def type_changed(self, type = "MAX"):
        return self.__type
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ProjectionVolumeStyle'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__intensityThreshold is not None:
            if isinstance(self.__intensityThreshold, six.string_types):
                str += ' intensityThreshold="'+self.__intensityThreshold+'"'
            else:
                str += ' intensityThreshold="'+self.__intensityThreshold[0]+'"'
        if self.__type is not None:
            if isinstance(self.__type, six.string_types):
                str += ' type="'+self.__type+'"'
            else:
                str += ' type="'+self.__type[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</ProjectionVolumeStyle>'
        return str


class ProtoInstance(X3DChildNode, X3DPrototypeInstance):
    def __init__(self, **kwargs):
        super(ProtoInstance, self).__init__(**kwargs)
        fieldValue  = kwargs.pop("fieldValue", None)
        self.__fieldValue = fieldValue
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        name  = kwargs.pop("name", None)
        self.__name = name
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def fieldValue(self):
        return self.__fieldValue
    @fieldValue.setter
    def fieldValue(self, value = None):
        self.__fieldValue = [value]
    def setFieldValue(self, fieldValue = None):
        self.__fieldValue = [fieldValue]
        return self
    def addFieldValue(self, fieldValue = None):
        if self.__fieldValue == None:            self.__fieldValue =  []
        self.__fieldValue +=  [fieldValue]
        return self
    def removeFieldValue(self, fieldValue):
        self.__fieldValue = [x for x in self.__fieldValue if x not in fieldValue]
        return self.__fieldValue
    def getFieldValue(self, fieldValue = None):
        return self.__fieldValue
    def fieldValue_changed(self, fieldValue = None):
        return self.__fieldValue
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        self.__name = [value]
    def setName(self, name = None):
        self.__name = [name]
        return self
    def addName(self, name = None):
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    @property
    def IS(self):
        return self.__IS
    @IS.setter
    def IS(self, value = None):
        self.__IS = [value]
    def setIS(self, IS = None):
        self.__IS = [IS]
        return self
    def addIS(self, IS = None):
        if self.__IS == None:            self.__IS =  []
        self.__IS +=  [IS]
        return self
    def removeIS(self, IS):
        self.__IS = [x for x in self.__IS if x not in IS]
        return self.__IS
    def getIS(self, IS = None):
        return self.__IS
    def IS_changed(self, IS = None):
        return self.__IS
    def toXML(self):
        str = ''
        str += '<ProtoInstance'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<fieldValue'
        if self.__fieldValue is not None:
           for s in self.__fieldValue:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__fieldValue is not None:
           for s in self.__fieldValue:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</fieldValue>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</ProtoInstance>'
        return str


class ProximitySensor(X3DEnvironmentalSensorNode):
    def __init__(self, **kwargs):
        super(ProximitySensor, self).__init__(**kwargs)
        center  = kwargs.pop("center", [0, 0, 0])
        self.__center = center
        centerOfRotation_changed  = kwargs.pop("centerOfRotation_changed", None)
        self.__centerOfRotation_changed = centerOfRotation_changed
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        enterTime  = kwargs.pop("enterTime", None)
        self.__enterTime = enterTime
        exitTime  = kwargs.pop("exitTime", None)
        self.__exitTime = exitTime
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        orientation_changed  = kwargs.pop("orientation_changed", None)
        self.__orientation_changed = orientation_changed
        position_changed  = kwargs.pop("position_changed", None)
        self.__position_changed = position_changed
        size  = kwargs.pop("size", [0, 0, 0])
        if size == None or len(size) <= 0 or min(size)  <  0:
            return None
        self.__size = size
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def center(self):
        return self.__center
    @center.setter
    def center(self, value = [0, 0, 0]):
        self.__center = [value]
    def setCenter(self, center = [0, 0, 0]):
        self.__center = [center]
        return self
    def addCenter(self, center = [0, 0, 0]):
        if self.__center == None:            self.__center =  []
        self.__center +=  [center]
        return self
    def removeCenter(self, center):
        self.__center = [x for x in self.__center if x not in center]
        return self.__center
    def getCenter(self, center = [0, 0, 0]):
        return self.__center
    def center_changed(self, center = [0, 0, 0]):
        return self.__center
    def removecenterOfRotation_changed(self, centerOfRotation_changed):
        self.__centerOfRotation_changed = [x for x in self.__centerOfRotation_changed if x not in centerOfRotation_changed]
        return self.__centerOfRotation_changed
    def getcenterOfRotation_changed(self, centerOfRotation_changed = None):
        return self.__centerOfRotation_changed
    def centerOfRotation_changed_changed(self, centerOfRotation_changed = None):
        return self.__centerOfRotation_changed
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    def removeEnterTime(self, enterTime):
        self.__enterTime = [x for x in self.__enterTime if x not in enterTime]
        return self.__enterTime
    def getEnterTime(self, enterTime = None):
        return self.__enterTime
    def enterTime_changed(self, enterTime = None):
        return self.__enterTime
    def removeExitTime(self, exitTime):
        self.__exitTime = [x for x in self.__exitTime if x not in exitTime]
        return self.__exitTime
    def getExitTime(self, exitTime = None):
        return self.__exitTime
    def exitTime_changed(self, exitTime = None):
        return self.__exitTime
    def isActive(self, Active = None):
        return self.__Active
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    def removeorientation_changed(self, orientation_changed):
        self.__orientation_changed = [x for x in self.__orientation_changed if x not in orientation_changed]
        return self.__orientation_changed
    def getorientation_changed(self, orientation_changed = None):
        return self.__orientation_changed
    def orientation_changed_changed(self, orientation_changed = None):
        return self.__orientation_changed
    def removeposition_changed(self, position_changed):
        self.__position_changed = [x for x in self.__position_changed if x not in position_changed]
        return self.__position_changed
    def getposition_changed(self, position_changed = None):
        return self.__position_changed
    def position_changed_changed(self, position_changed = None):
        return self.__position_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ProximitySensor'
        if self.__center is not None:
            if isinstance(self.__center, six.string_types):
                str += ' center="'+self.__center+'"'
            else:
                str += ' center="'+self.__center[0]+'"'
        if self.__centerOfRotation_changed is not None:
            if isinstance(self.__centerOfRotation_changed, six.string_types):
                str += ' centerOfRotation_changed="'+self.__centerOfRotation_changed+'"'
            else:
                str += ' centerOfRotation_changed="'+self.__centerOfRotation_changed[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__enterTime is not None:
            if isinstance(self.__enterTime, six.string_types):
                str += ' enterTime="'+self.__enterTime+'"'
            else:
                str += ' enterTime="'+self.__enterTime[0]+'"'
        if self.__exitTime is not None:
            if isinstance(self.__exitTime, six.string_types):
                str += ' exitTime="'+self.__exitTime+'"'
            else:
                str += ' exitTime="'+self.__exitTime[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__orientation_changed is not None:
            if isinstance(self.__orientation_changed, six.string_types):
                str += ' orientation_changed="'+self.__orientation_changed+'"'
            else:
                str += ' orientation_changed="'+self.__orientation_changed[0]+'"'
        if self.__position_changed is not None:
            if isinstance(self.__position_changed, six.string_types):
                str += ' position_changed="'+self.__position_changed+'"'
            else:
                str += ' position_changed="'+self.__position_changed[0]+'"'
        if self.__size is not None:
            if isinstance(self.__size, six.string_types):
                str += ' size="'+self.__size+'"'
            else:
                str += ' size="'+self.__size[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</ProximitySensor>'
        return str


class QuadSet(X3DComposedGeometryNode):
    def __init__(self, **kwargs):
        super(QuadSet, self).__init__(**kwargs)
        attrib  = kwargs.pop("attrib", None)
        self.__attrib = attrib
        ccw  = kwargs.pop("ccw", True)
        self.__ccw = ccw
        color  = kwargs.pop("color", None)
        self.__color = color
        colorPerVertex  = kwargs.pop("colorPerVertex", True)
        self.__colorPerVertex = colorPerVertex
        coord  = kwargs.pop("coord", None)
        self.__coord = coord
        fogCoord  = kwargs.pop("fogCoord", None)
        self.__fogCoord = fogCoord
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        normal  = kwargs.pop("normal", None)
        self.__normal = normal
        normalPerVertex  = kwargs.pop("normalPerVertex", True)
        self.__normalPerVertex = normalPerVertex
        solid  = kwargs.pop("solid", True)
        self.__solid = solid
        texCoord  = kwargs.pop("texCoord", None)
        self.__texCoord = texCoord
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def attrib(self):
        return self.__attrib
    @attrib.setter
    def attrib(self, value = None):
        self.__attrib = [value]
    def setAttrib(self, attrib = None):
        self.__attrib = [attrib]
        return self
    def addAttrib(self, attrib = None):
        if self.__attrib == None:            self.__attrib =  []
        self.__attrib +=  [attrib]
        return self
    def removeAttrib(self, attrib):
        self.__attrib = [x for x in self.__attrib if x not in attrib]
        return self.__attrib
    def getAttrib(self, attrib = None):
        return self.__attrib
    def attrib_changed(self, attrib = None):
        return self.__attrib
    @property
    def color(self):
        return self.__color
    @color.setter
    def color(self, value = None):
        self.__color = [value]
    def setColor(self, color = None):
        self.__color = [color]
        return self
    def addColor(self, color = None):
        if self.__color == None:            self.__color =  []
        self.__color +=  [color]
        return self
    def removeColor(self, color):
        self.__color = [x for x in self.__color if x not in color]
        return self.__color
    def getColor(self, color = None):
        return self.__color
    def color_changed(self, color = None):
        return self.__color
    @property
    def coord(self):
        return self.__coord
    @coord.setter
    def coord(self, value = None):
        self.__coord = [value]
    def setCoord(self, coord = None):
        self.__coord = [coord]
        return self
    def addCoord(self, coord = None):
        if self.__coord == None:            self.__coord =  []
        self.__coord +=  [coord]
        return self
    def removeCoord(self, coord):
        self.__coord = [x for x in self.__coord if x not in coord]
        return self.__coord
    def getCoord(self, coord = None):
        return self.__coord
    def coord_changed(self, coord = None):
        return self.__coord
    @property
    def fogCoord(self):
        return self.__fogCoord
    @fogCoord.setter
    def fogCoord(self, value = None):
        self.__fogCoord = [value]
    def setFogCoord(self, fogCoord = None):
        self.__fogCoord = [fogCoord]
        return self
    def addFogCoord(self, fogCoord = None):
        if self.__fogCoord == None:            self.__fogCoord =  []
        self.__fogCoord +=  [fogCoord]
        return self
    def removeFogCoord(self, fogCoord):
        self.__fogCoord = [x for x in self.__fogCoord if x not in fogCoord]
        return self.__fogCoord
    def getFogCoord(self, fogCoord = None):
        return self.__fogCoord
    def fogCoord_changed(self, fogCoord = None):
        return self.__fogCoord
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def normal(self):
        return self.__normal
    @normal.setter
    def normal(self, value = None):
        self.__normal = [value]
    def setNormal(self, normal = None):
        self.__normal = [normal]
        return self
    def addNormal(self, normal = None):
        if self.__normal == None:            self.__normal =  []
        self.__normal +=  [normal]
        return self
    def removeNormal(self, normal):
        self.__normal = [x for x in self.__normal if x not in normal]
        return self.__normal
    def getNormal(self, normal = None):
        return self.__normal
    def normal_changed(self, normal = None):
        return self.__normal
    @property
    def texCoord(self):
        return self.__texCoord
    @texCoord.setter
    def texCoord(self, value = None):
        self.__texCoord = [value]
    def setTexCoord(self, texCoord = None):
        self.__texCoord = [texCoord]
        return self
    def addTexCoord(self, texCoord = None):
        if self.__texCoord == None:            self.__texCoord =  []
        self.__texCoord +=  [texCoord]
        return self
    def removeTexCoord(self, texCoord):
        self.__texCoord = [x for x in self.__texCoord if x not in texCoord]
        return self.__texCoord
    def getTexCoord(self, texCoord = None):
        return self.__texCoord
    def texCoord_changed(self, texCoord = None):
        return self.__texCoord
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<QuadSet'
        if self.__ccw is not None:
            if isinstance(self.__ccw, six.string_types):
                str += ' ccw="'+self.__ccw+'"'
            else:
                str += ' ccw="'+self.__ccw[0]+'"'
        if self.__colorPerVertex is not None:
            if isinstance(self.__colorPerVertex, six.string_types):
                str += ' colorPerVertex="'+self.__colorPerVertex+'"'
            else:
                str += ' colorPerVertex="'+self.__colorPerVertex[0]+'"'
        if self.__normalPerVertex is not None:
            if isinstance(self.__normalPerVertex, six.string_types):
                str += ' normalPerVertex="'+self.__normalPerVertex+'"'
            else:
                str += ' normalPerVertex="'+self.__normalPerVertex[0]+'"'
        if self.__solid is not None:
            if isinstance(self.__solid, six.string_types):
                str += ' solid="'+self.__solid+'"'
            else:
                str += ' solid="'+self.__solid[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<attrib'
        if self.__attrib is not None:
           for s in self.__attrib:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__attrib is not None:
           for s in self.__attrib:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</attrib>'
        str += '<color'
        if self.__color is not None:
           for s in self.__color:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__color is not None:
           for s in self.__color:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</color>'
        str += '<coord'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</coord>'
        str += '<fogCoord'
        if self.__fogCoord is not None:
           for s in self.__fogCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__fogCoord is not None:
           for s in self.__fogCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</fogCoord>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<normal'
        if self.__normal is not None:
           for s in self.__normal:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__normal is not None:
           for s in self.__normal:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</normal>'
        str += '<texCoord'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</texCoord>'
        str += '</QuadSet>'
        return str


class ReceiverPdu(X3DBoundedObject, X3DNetworkSensorNode):
    def __init__(self, **kwargs):
        super(ReceiverPdu, self).__init__(**kwargs)
        address  = kwargs.pop("address", "localhost")
        self.__address = address
        applicationID  = kwargs.pop("applicationID", 0)
        self.__applicationID = applicationID
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        entityID  = kwargs.pop("entityID", 0)
        self.__entityID = entityID
        geoCoords  = kwargs.pop("geoCoords", [0, 0, 0])
        self.__geoCoords = geoCoords
        geoSystem  = kwargs.pop("geoSystem", ["GD", "WE"])
        self.__geoSystem = geoSystem
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        NetworkReader  = kwargs.pop("NetworkReader", None)
        self.__NetworkReader = NetworkReader
        NetworkWriter  = kwargs.pop("NetworkWriter", None)
        self.__NetworkWriter = NetworkWriter
        RtpHeaderHeard  = kwargs.pop("RtpHeaderHeard", None)
        self.__RtpHeaderHeard = RtpHeaderHeard
        StandAlone  = kwargs.pop("StandAlone", None)
        self.__StandAlone = StandAlone
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        multicastRelayHost  = kwargs.pop("multicastRelayHost", None)
        self.__multicastRelayHost = multicastRelayHost
        multicastRelayPort  = kwargs.pop("multicastRelayPort", 0)
        self.__multicastRelayPort = multicastRelayPort
        networkMode  = kwargs.pop("networkMode", "standAlone")
        if 'standAlone' == networkMode:
            pass
        elif 'networkReader' == networkMode:
            pass
        elif 'networkWriter' == networkMode:
            pass
        else:
            return None
        self.__networkMode = networkMode
        port  = kwargs.pop("port", 0)
        self.__port = port
        radioID  = kwargs.pop("radioID", 0)
        self.__radioID = radioID
        readInterval  = kwargs.pop("readInterval", 0.1)
        if readInterval == None or readInterval  <  0:
            return None
        self.__readInterval = readInterval
        receivedPower  = kwargs.pop("receivedPower", 0.0)
        self.__receivedPower = receivedPower
        receiverState  = kwargs.pop("receiverState", 0)
        self.__receiverState = receiverState
        rtpHeaderExpected  = kwargs.pop("rtpHeaderExpected", False)
        self.__rtpHeaderExpected = rtpHeaderExpected
        siteID  = kwargs.pop("siteID", 0)
        self.__siteID = siteID
        timestamp  = kwargs.pop("timestamp", None)
        if timestamp == None or timestamp  <  0:
            return None
        self.__timestamp = timestamp
        transmitterApplicationID  = kwargs.pop("transmitterApplicationID", 0)
        self.__transmitterApplicationID = transmitterApplicationID
        transmitterEntityID  = kwargs.pop("transmitterEntityID", 0)
        self.__transmitterEntityID = transmitterEntityID
        transmitterRadioID  = kwargs.pop("transmitterRadioID", 0)
        self.__transmitterRadioID = transmitterRadioID
        transmitterSiteID  = kwargs.pop("transmitterSiteID", 0)
        self.__transmitterSiteID = transmitterSiteID
        whichGeometry  = kwargs.pop("whichGeometry", 1)
        self.__whichGeometry = whichGeometry
        writeInterval  = kwargs.pop("writeInterval", 1.0)
        if writeInterval == None or writeInterval  <  0:
            return None
        self.__writeInterval = writeInterval
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def address(self):
        return self.__address
    @address.setter
    def address(self, value = "localhost"):
        self.__address = [value]
    def address(self, address = "localhost"):
        if self.__address == None:            self.__address =  []
        self.__address +=  [address]
        return self
    def removeAddress(self, address):
        self.__address = [x for x in self.__address if x not in address]
        return self.__address
    def getAddress(self, address = "localhost"):
        return self.__address
    def address_changed(self, address = "localhost"):
        return self.__address
    @property
    def applicationID(self):
        return self.__applicationID
    @applicationID.setter
    def applicationID(self, value = 0):
        self.__applicationID = [value]
    def setApplicationID(self, applicationID = 0):
        self.__applicationID = [applicationID]
        return self
    def addApplicationID(self, applicationID = 0):
        if self.__applicationID == None:            self.__applicationID =  []
        self.__applicationID +=  [applicationID]
        return self
    def removeApplicationID(self, applicationID):
        self.__applicationID = [x for x in self.__applicationID if x not in applicationID]
        return self.__applicationID
    def getApplicationID(self, applicationID = 0):
        return self.__applicationID
    def applicationID_changed(self, applicationID = 0):
        return self.__applicationID
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def entityID(self):
        return self.__entityID
    @entityID.setter
    def entityID(self, value = 0):
        self.__entityID = [value]
    def setEntityID(self, entityID = 0):
        self.__entityID = [entityID]
        return self
    def addEntityID(self, entityID = 0):
        if self.__entityID == None:            self.__entityID =  []
        self.__entityID +=  [entityID]
        return self
    def removeEntityID(self, entityID):
        self.__entityID = [x for x in self.__entityID if x not in entityID]
        return self.__entityID
    def getEntityID(self, entityID = 0):
        return self.__entityID
    def entityID_changed(self, entityID = 0):
        return self.__entityID
    @property
    def geoCoords(self):
        return self.__geoCoords
    @geoCoords.setter
    def geoCoords(self, value = [0, 0, 0]):
        self.__geoCoords = [value]
    def setGeoCoords(self, geoCoords = [0, 0, 0]):
        self.__geoCoords = [geoCoords]
        return self
    def addGeoCoords(self, geoCoords = [0, 0, 0]):
        if self.__geoCoords == None:            self.__geoCoords =  []
        self.__geoCoords +=  [geoCoords]
        return self
    def removeGeoCoords(self, geoCoords):
        self.__geoCoords = [x for x in self.__geoCoords if x not in geoCoords]
        return self.__geoCoords
    def getGeoCoords(self, geoCoords = [0, 0, 0]):
        return self.__geoCoords
    def geoCoords_changed(self, geoCoords = [0, 0, 0]):
        return self.__geoCoords
    def isActive(self, Active = None):
        return self.__Active
    def isNetworkReader(self, NetworkReader = None):
        return self.__NetworkReader
    def isNetworkWriter(self, NetworkWriter = None):
        return self.__NetworkWriter
    def isRtpHeaderHeard(self, RtpHeaderHeard = None):
        return self.__RtpHeaderHeard
    def isStandAlone(self, StandAlone = None):
        return self.__StandAlone
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def multicastRelayHost(self):
        return self.__multicastRelayHost
    @multicastRelayHost.setter
    def multicastRelayHost(self, value = None):
        self.__multicastRelayHost = [value]
    def setMulticastRelayHost(self, multicastRelayHost = None):
        self.__multicastRelayHost = [multicastRelayHost]
        return self
    def addMulticastRelayHost(self, multicastRelayHost = None):
        if self.__multicastRelayHost == None:            self.__multicastRelayHost =  []
        self.__multicastRelayHost +=  [multicastRelayHost]
        return self
    def removeMulticastRelayHost(self, multicastRelayHost):
        self.__multicastRelayHost = [x for x in self.__multicastRelayHost if x not in multicastRelayHost]
        return self.__multicastRelayHost
    def getMulticastRelayHost(self, multicastRelayHost = None):
        return self.__multicastRelayHost
    def multicastRelayHost_changed(self, multicastRelayHost = None):
        return self.__multicastRelayHost
    @property
    def multicastRelayPort(self):
        return self.__multicastRelayPort
    @multicastRelayPort.setter
    def multicastRelayPort(self, value = 0):
        self.__multicastRelayPort = [value]
    def setMulticastRelayPort(self, multicastRelayPort = 0):
        self.__multicastRelayPort = [multicastRelayPort]
        return self
    def addMulticastRelayPort(self, multicastRelayPort = 0):
        if self.__multicastRelayPort == None:            self.__multicastRelayPort =  []
        self.__multicastRelayPort +=  [multicastRelayPort]
        return self
    def removeMulticastRelayPort(self, multicastRelayPort):
        self.__multicastRelayPort = [x for x in self.__multicastRelayPort if x not in multicastRelayPort]
        return self.__multicastRelayPort
    def getMulticastRelayPort(self, multicastRelayPort = 0):
        return self.__multicastRelayPort
    def multicastRelayPort_changed(self, multicastRelayPort = 0):
        return self.__multicastRelayPort
    @property
    def networkMode(self):
        return self.__networkMode
    @networkMode.setter
    def networkMode(self, value = "standAlone"):
        if 'standAlone' == value:
            pass
        elif 'networkReader' == value:
            pass
        elif 'networkWriter' == value:
            pass
        else:
            return None
        self.__networkMode = [value]
    def setNetworkMode(self, networkMode = "standAlone"):
        if 'standAlone' == networkMode:
            pass
        elif 'networkReader' == networkMode:
            pass
        elif 'networkWriter' == networkMode:
            pass
        else:
            return None
        self.__networkMode = [networkMode]
        return self
    def addNetworkMode(self, networkMode = "standAlone"):
        if 'standAlone' == networkMode:
            pass
        elif 'networkReader' == networkMode:
            pass
        elif 'networkWriter' == networkMode:
            pass
        else:
            return None
        if self.__networkMode == None:            self.__networkMode =  []
        self.__networkMode +=  [networkMode]
        return self
    def removeNetworkMode(self, networkMode):
        self.__networkMode = [x for x in self.__networkMode if x not in networkMode]
        return self.__networkMode
    def getNetworkMode(self, networkMode = "standAlone"):
        return self.__networkMode
    def networkMode_changed(self, networkMode = "standAlone"):
        return self.__networkMode
    @property
    def port(self):
        return self.__port
    @port.setter
    def port(self, value = 0):
        self.__port = [value]
    def setPort(self, port = 0):
        self.__port = [port]
        return self
    def addPort(self, port = 0):
        if self.__port == None:            self.__port =  []
        self.__port +=  [port]
        return self
    def removePort(self, port):
        self.__port = [x for x in self.__port if x not in port]
        return self.__port
    def getPort(self, port = 0):
        return self.__port
    def port_changed(self, port = 0):
        return self.__port
    @property
    def radioID(self):
        return self.__radioID
    @radioID.setter
    def radioID(self, value = 0):
        self.__radioID = [value]
    def setRadioID(self, radioID = 0):
        self.__radioID = [radioID]
        return self
    def addRadioID(self, radioID = 0):
        if self.__radioID == None:            self.__radioID =  []
        self.__radioID +=  [radioID]
        return self
    def removeRadioID(self, radioID):
        self.__radioID = [x for x in self.__radioID if x not in radioID]
        return self.__radioID
    def getRadioID(self, radioID = 0):
        return self.__radioID
    def radioID_changed(self, radioID = 0):
        return self.__radioID
    @property
    def readInterval(self):
        return self.__readInterval
    @readInterval.setter
    def readInterval(self, value = 0.1):
        if value == None or value  <  0:
            return None
        self.__readInterval = [value]
    def setReadInterval(self, readInterval = 0.1):
        if readInterval == None or readInterval  <  0:
            return None
        self.__readInterval = [readInterval]
        return self
    def addReadInterval(self, readInterval = 0.1):
        if readInterval == None or readInterval  <  0:
            return None
        if self.__readInterval == None:            self.__readInterval =  []
        self.__readInterval +=  [readInterval]
        return self
    def removeReadInterval(self, readInterval):
        self.__readInterval = [x for x in self.__readInterval if x not in readInterval]
        return self.__readInterval
    def getReadInterval(self, readInterval = 0.1):
        return self.__readInterval
    def readInterval_changed(self, readInterval = 0.1):
        return self.__readInterval
    @property
    def receivedPower(self):
        return self.__receivedPower
    @receivedPower.setter
    def receivedPower(self, value = 0.0):
        self.__receivedPower = [value]
    def setReceivedPower(self, receivedPower = 0.0):
        self.__receivedPower = [receivedPower]
        return self
    def addReceivedPower(self, receivedPower = 0.0):
        if self.__receivedPower == None:            self.__receivedPower =  []
        self.__receivedPower +=  [receivedPower]
        return self
    def removeReceivedPower(self, receivedPower):
        self.__receivedPower = [x for x in self.__receivedPower if x not in receivedPower]
        return self.__receivedPower
    def getReceivedPower(self, receivedPower = 0.0):
        return self.__receivedPower
    def receivedPower_changed(self, receivedPower = 0.0):
        return self.__receivedPower
    @property
    def receiverState(self):
        return self.__receiverState
    @receiverState.setter
    def receiverState(self, value = 0):
        self.__receiverState = [value]
    def setReceiverState(self, receiverState = 0):
        self.__receiverState = [receiverState]
        return self
    def addReceiverState(self, receiverState = 0):
        if self.__receiverState == None:            self.__receiverState =  []
        self.__receiverState +=  [receiverState]
        return self
    def removeReceiverState(self, receiverState):
        self.__receiverState = [x for x in self.__receiverState if x not in receiverState]
        return self.__receiverState
    def getReceiverState(self, receiverState = 0):
        return self.__receiverState
    def receiverState_changed(self, receiverState = 0):
        return self.__receiverState
    @property
    def siteID(self):
        return self.__siteID
    @siteID.setter
    def siteID(self, value = 0):
        self.__siteID = [value]
    def setSiteID(self, siteID = 0):
        self.__siteID = [siteID]
        return self
    def addSiteID(self, siteID = 0):
        if self.__siteID == None:            self.__siteID =  []
        self.__siteID +=  [siteID]
        return self
    def removeSiteID(self, siteID):
        self.__siteID = [x for x in self.__siteID if x not in siteID]
        return self.__siteID
    def getSiteID(self, siteID = 0):
        return self.__siteID
    def siteID_changed(self, siteID = 0):
        return self.__siteID
    def removeTimestamp(self, timestamp):
        self.__timestamp = [x for x in self.__timestamp if x not in timestamp]
        return self.__timestamp
    def getTimestamp(self, timestamp = None):
        return self.__timestamp
    def timestamp_changed(self, timestamp = None):
        return self.__timestamp
    @property
    def transmitterApplicationID(self):
        return self.__transmitterApplicationID
    @transmitterApplicationID.setter
    def transmitterApplicationID(self, value = 0):
        self.__transmitterApplicationID = [value]
    def setTransmitterApplicationID(self, transmitterApplicationID = 0):
        self.__transmitterApplicationID = [transmitterApplicationID]
        return self
    def addTransmitterApplicationID(self, transmitterApplicationID = 0):
        if self.__transmitterApplicationID == None:            self.__transmitterApplicationID =  []
        self.__transmitterApplicationID +=  [transmitterApplicationID]
        return self
    def removeTransmitterApplicationID(self, transmitterApplicationID):
        self.__transmitterApplicationID = [x for x in self.__transmitterApplicationID if x not in transmitterApplicationID]
        return self.__transmitterApplicationID
    def getTransmitterApplicationID(self, transmitterApplicationID = 0):
        return self.__transmitterApplicationID
    def transmitterApplicationID_changed(self, transmitterApplicationID = 0):
        return self.__transmitterApplicationID
    @property
    def transmitterEntityID(self):
        return self.__transmitterEntityID
    @transmitterEntityID.setter
    def transmitterEntityID(self, value = 0):
        self.__transmitterEntityID = [value]
    def setTransmitterEntityID(self, transmitterEntityID = 0):
        self.__transmitterEntityID = [transmitterEntityID]
        return self
    def addTransmitterEntityID(self, transmitterEntityID = 0):
        if self.__transmitterEntityID == None:            self.__transmitterEntityID =  []
        self.__transmitterEntityID +=  [transmitterEntityID]
        return self
    def removeTransmitterEntityID(self, transmitterEntityID):
        self.__transmitterEntityID = [x for x in self.__transmitterEntityID if x not in transmitterEntityID]
        return self.__transmitterEntityID
    def getTransmitterEntityID(self, transmitterEntityID = 0):
        return self.__transmitterEntityID
    def transmitterEntityID_changed(self, transmitterEntityID = 0):
        return self.__transmitterEntityID
    @property
    def transmitterRadioID(self):
        return self.__transmitterRadioID
    @transmitterRadioID.setter
    def transmitterRadioID(self, value = 0):
        self.__transmitterRadioID = [value]
    def setTransmitterRadioID(self, transmitterRadioID = 0):
        self.__transmitterRadioID = [transmitterRadioID]
        return self
    def addTransmitterRadioID(self, transmitterRadioID = 0):
        if self.__transmitterRadioID == None:            self.__transmitterRadioID =  []
        self.__transmitterRadioID +=  [transmitterRadioID]
        return self
    def removeTransmitterRadioID(self, transmitterRadioID):
        self.__transmitterRadioID = [x for x in self.__transmitterRadioID if x not in transmitterRadioID]
        return self.__transmitterRadioID
    def getTransmitterRadioID(self, transmitterRadioID = 0):
        return self.__transmitterRadioID
    def transmitterRadioID_changed(self, transmitterRadioID = 0):
        return self.__transmitterRadioID
    @property
    def transmitterSiteID(self):
        return self.__transmitterSiteID
    @transmitterSiteID.setter
    def transmitterSiteID(self, value = 0):
        self.__transmitterSiteID = [value]
    def setTransmitterSiteID(self, transmitterSiteID = 0):
        self.__transmitterSiteID = [transmitterSiteID]
        return self
    def addTransmitterSiteID(self, transmitterSiteID = 0):
        if self.__transmitterSiteID == None:            self.__transmitterSiteID =  []
        self.__transmitterSiteID +=  [transmitterSiteID]
        return self
    def removeTransmitterSiteID(self, transmitterSiteID):
        self.__transmitterSiteID = [x for x in self.__transmitterSiteID if x not in transmitterSiteID]
        return self.__transmitterSiteID
    def getTransmitterSiteID(self, transmitterSiteID = 0):
        return self.__transmitterSiteID
    def transmitterSiteID_changed(self, transmitterSiteID = 0):
        return self.__transmitterSiteID
    @property
    def whichGeometry(self):
        return self.__whichGeometry
    @whichGeometry.setter
    def whichGeometry(self, value = 1):
        self.__whichGeometry = [value]
    def setWhichGeometry(self, whichGeometry = 1):
        self.__whichGeometry = [whichGeometry]
        return self
    def addWhichGeometry(self, whichGeometry = 1):
        if self.__whichGeometry == None:            self.__whichGeometry =  []
        self.__whichGeometry +=  [whichGeometry]
        return self
    def removeWhichGeometry(self, whichGeometry):
        self.__whichGeometry = [x for x in self.__whichGeometry if x not in whichGeometry]
        return self.__whichGeometry
    def getWhichGeometry(self, whichGeometry = 1):
        return self.__whichGeometry
    def whichGeometry_changed(self, whichGeometry = 1):
        return self.__whichGeometry
    @property
    def writeInterval(self):
        return self.__writeInterval
    @writeInterval.setter
    def writeInterval(self, value = 1.0):
        if value == None or value  <  0:
            return None
        self.__writeInterval = [value]
    def setWriteInterval(self, writeInterval = 1.0):
        if writeInterval == None or writeInterval  <  0:
            return None
        self.__writeInterval = [writeInterval]
        return self
    def addWriteInterval(self, writeInterval = 1.0):
        if writeInterval == None or writeInterval  <  0:
            return None
        if self.__writeInterval == None:            self.__writeInterval =  []
        self.__writeInterval +=  [writeInterval]
        return self
    def removeWriteInterval(self, writeInterval):
        self.__writeInterval = [x for x in self.__writeInterval if x not in writeInterval]
        return self.__writeInterval
    def getWriteInterval(self, writeInterval = 1.0):
        return self.__writeInterval
    def writeInterval_changed(self, writeInterval = 1.0):
        return self.__writeInterval
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ReceiverPdu'
        if self.__address is not None:
            if isinstance(self.__address, six.string_types):
                str += ' address="'+self.__address+'"'
            else:
                str += ' address="'+self.__address[0]+'"'
        if self.__applicationID is not None:
            if isinstance(self.__applicationID, six.string_types):
                str += ' applicationID="'+self.__applicationID+'"'
            else:
                str += ' applicationID="'+self.__applicationID[0]+'"'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__entityID is not None:
            if isinstance(self.__entityID, six.string_types):
                str += ' entityID="'+self.__entityID+'"'
            else:
                str += ' entityID="'+self.__entityID[0]+'"'
        if self.__geoCoords is not None:
            if isinstance(self.__geoCoords, six.string_types):
                str += ' geoCoords="'+self.__geoCoords+'"'
            else:
                str += ' geoCoords="'+self.__geoCoords[0]+'"'
        if self.__geoSystem is not None:
            if isinstance(self.__geoSystem, six.string_types):
                str += ' geoSystem="'+self.__geoSystem+'"'
            else:
                str += ' geoSystem="'+self.__geoSystem[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__NetworkReader is not None:
            if isinstance(self.__NetworkReader, six.string_types):
                str += ' NetworkReader="'+self.__NetworkReader+'"'
            else:
                str += ' NetworkReader="'+self.__NetworkReader[0]+'"'
        if self.__NetworkWriter is not None:
            if isinstance(self.__NetworkWriter, six.string_types):
                str += ' NetworkWriter="'+self.__NetworkWriter+'"'
            else:
                str += ' NetworkWriter="'+self.__NetworkWriter[0]+'"'
        if self.__RtpHeaderHeard is not None:
            if isinstance(self.__RtpHeaderHeard, six.string_types):
                str += ' RtpHeaderHeard="'+self.__RtpHeaderHeard+'"'
            else:
                str += ' RtpHeaderHeard="'+self.__RtpHeaderHeard[0]+'"'
        if self.__StandAlone is not None:
            if isinstance(self.__StandAlone, six.string_types):
                str += ' StandAlone="'+self.__StandAlone+'"'
            else:
                str += ' StandAlone="'+self.__StandAlone[0]+'"'
        if self.__multicastRelayHost is not None:
            if isinstance(self.__multicastRelayHost, six.string_types):
                str += ' multicastRelayHost="'+self.__multicastRelayHost+'"'
            else:
                str += ' multicastRelayHost="'+self.__multicastRelayHost[0]+'"'
        if self.__multicastRelayPort is not None:
            if isinstance(self.__multicastRelayPort, six.string_types):
                str += ' multicastRelayPort="'+self.__multicastRelayPort+'"'
            else:
                str += ' multicastRelayPort="'+self.__multicastRelayPort[0]+'"'
        if self.__networkMode is not None:
            if isinstance(self.__networkMode, six.string_types):
                str += ' networkMode="'+self.__networkMode+'"'
            else:
                str += ' networkMode="'+self.__networkMode[0]+'"'
        if self.__port is not None:
            if isinstance(self.__port, six.string_types):
                str += ' port="'+self.__port+'"'
            else:
                str += ' port="'+self.__port[0]+'"'
        if self.__radioID is not None:
            if isinstance(self.__radioID, six.string_types):
                str += ' radioID="'+self.__radioID+'"'
            else:
                str += ' radioID="'+self.__radioID[0]+'"'
        if self.__readInterval is not None:
            if isinstance(self.__readInterval, six.string_types):
                str += ' readInterval="'+self.__readInterval+'"'
            else:
                str += ' readInterval="'+self.__readInterval[0]+'"'
        if self.__receivedPower is not None:
            if isinstance(self.__receivedPower, six.string_types):
                str += ' receivedPower="'+self.__receivedPower+'"'
            else:
                str += ' receivedPower="'+self.__receivedPower[0]+'"'
        if self.__receiverState is not None:
            if isinstance(self.__receiverState, six.string_types):
                str += ' receiverState="'+self.__receiverState+'"'
            else:
                str += ' receiverState="'+self.__receiverState[0]+'"'
        if self.__rtpHeaderExpected is not None:
            if isinstance(self.__rtpHeaderExpected, six.string_types):
                str += ' rtpHeaderExpected="'+self.__rtpHeaderExpected+'"'
            else:
                str += ' rtpHeaderExpected="'+self.__rtpHeaderExpected[0]+'"'
        if self.__siteID is not None:
            if isinstance(self.__siteID, six.string_types):
                str += ' siteID="'+self.__siteID+'"'
            else:
                str += ' siteID="'+self.__siteID[0]+'"'
        if self.__timestamp is not None:
            if isinstance(self.__timestamp, six.string_types):
                str += ' timestamp="'+self.__timestamp+'"'
            else:
                str += ' timestamp="'+self.__timestamp[0]+'"'
        if self.__transmitterApplicationID is not None:
            if isinstance(self.__transmitterApplicationID, six.string_types):
                str += ' transmitterApplicationID="'+self.__transmitterApplicationID+'"'
            else:
                str += ' transmitterApplicationID="'+self.__transmitterApplicationID[0]+'"'
        if self.__transmitterEntityID is not None:
            if isinstance(self.__transmitterEntityID, six.string_types):
                str += ' transmitterEntityID="'+self.__transmitterEntityID+'"'
            else:
                str += ' transmitterEntityID="'+self.__transmitterEntityID[0]+'"'
        if self.__transmitterRadioID is not None:
            if isinstance(self.__transmitterRadioID, six.string_types):
                str += ' transmitterRadioID="'+self.__transmitterRadioID+'"'
            else:
                str += ' transmitterRadioID="'+self.__transmitterRadioID[0]+'"'
        if self.__transmitterSiteID is not None:
            if isinstance(self.__transmitterSiteID, six.string_types):
                str += ' transmitterSiteID="'+self.__transmitterSiteID+'"'
            else:
                str += ' transmitterSiteID="'+self.__transmitterSiteID[0]+'"'
        if self.__whichGeometry is not None:
            if isinstance(self.__whichGeometry, six.string_types):
                str += ' whichGeometry="'+self.__whichGeometry+'"'
            else:
                str += ' whichGeometry="'+self.__whichGeometry[0]+'"'
        if self.__writeInterval is not None:
            if isinstance(self.__writeInterval, six.string_types):
                str += ' writeInterval="'+self.__writeInterval+'"'
            else:
                str += ' writeInterval="'+self.__writeInterval[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</ReceiverPdu>'
        return str


class Rectangle2D(X3DGeometryNode):
    def __init__(self, **kwargs):
        super(Rectangle2D, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        size  = kwargs.pop("size", [2, 2])
        if size == None or len(size) <= 0 or min(size)  <=  0:
            return None
        self.__size = size
        solid  = kwargs.pop("solid", False)
        self.__solid = solid
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Rectangle2D'
        if self.__size is not None:
            if isinstance(self.__size, six.string_types):
                str += ' size="'+self.__size+'"'
            else:
                str += ' size="'+self.__size[0]+'"'
        if self.__solid is not None:
            if isinstance(self.__solid, six.string_types):
                str += ' solid="'+self.__solid+'"'
            else:
                str += ' solid="'+self.__solid[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</Rectangle2D>'
        return str


class RigidBody(X3DNode):
    def __init__(self, **kwargs):
        super(RigidBody, self).__init__(**kwargs)
        angularDampingFactor  = kwargs.pop("angularDampingFactor", 0.001)
        self.__angularDampingFactor = angularDampingFactor
        angularVelocity  = kwargs.pop("angularVelocity", [0, 0, 0])
        self.__angularVelocity = angularVelocity
        autoDamp  = kwargs.pop("autoDamp", False)
        self.__autoDamp = autoDamp
        autoDisable  = kwargs.pop("autoDisable", False)
        self.__autoDisable = autoDisable
        centerOfMass  = kwargs.pop("centerOfMass", [0, 0, 0])
        self.__centerOfMass = centerOfMass
        disableAngularSpeed  = kwargs.pop("disableAngularSpeed", 0)
        self.__disableAngularSpeed = disableAngularSpeed
        disableLinearSpeed  = kwargs.pop("disableLinearSpeed", 0)
        self.__disableLinearSpeed = disableLinearSpeed
        disableTime  = kwargs.pop("disableTime", 0)
        if disableTime == None or disableTime  <  0:
            return None
        self.__disableTime = disableTime
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        finiteRotationAxis  = kwargs.pop("finiteRotationAxis", [0, 1, 0])
        self.__finiteRotationAxis = finiteRotationAxis
        fixed  = kwargs.pop("fixed", False)
        self.__fixed = fixed
        forces  = kwargs.pop("forces", None)
        self.__forces = forces
        geometry  = kwargs.pop("geometry", None)
        self.__geometry = geometry
        inertia  = kwargs.pop("inertia", [1, 0, 0, 0, 1, 0, 0, 0, 1])
        self.__inertia = inertia
        linearDampingFactor  = kwargs.pop("linearDampingFactor", 0.001)
        self.__linearDampingFactor = linearDampingFactor
        linearVelocity  = kwargs.pop("linearVelocity", [0, 0, 0])
        self.__linearVelocity = linearVelocity
        mass  = kwargs.pop("mass", 1)
        self.__mass = mass
        massDensityModel  = kwargs.pop("massDensityModel", None)
        self.__massDensityModel = massDensityModel
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        orientation  = kwargs.pop("orientation", [0, 0, 1, 0])
        self.__orientation = orientation
        position  = kwargs.pop("position", [0, 0, 0])
        self.__position = position
        torques  = kwargs.pop("torques", None)
        self.__torques = torques
        useFiniteRotation  = kwargs.pop("useFiniteRotation", False)
        self.__useFiniteRotation = useFiniteRotation
        useGlobalGravity  = kwargs.pop("useGlobalGravity", True)
        self.__useGlobalGravity = useGlobalGravity
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def angularDampingFactor(self):
        return self.__angularDampingFactor
    @angularDampingFactor.setter
    def angularDampingFactor(self, value = 0.001):
        self.__angularDampingFactor = [value]
    def setAngularDampingFactor(self, angularDampingFactor = 0.001):
        self.__angularDampingFactor = [angularDampingFactor]
        return self
    def addAngularDampingFactor(self, angularDampingFactor = 0.001):
        if self.__angularDampingFactor == None:            self.__angularDampingFactor =  []
        self.__angularDampingFactor +=  [angularDampingFactor]
        return self
    def removeAngularDampingFactor(self, angularDampingFactor):
        self.__angularDampingFactor = [x for x in self.__angularDampingFactor if x not in angularDampingFactor]
        return self.__angularDampingFactor
    def getAngularDampingFactor(self, angularDampingFactor = 0.001):
        return self.__angularDampingFactor
    def angularDampingFactor_changed(self, angularDampingFactor = 0.001):
        return self.__angularDampingFactor
    @property
    def angularVelocity(self):
        return self.__angularVelocity
    @angularVelocity.setter
    def angularVelocity(self, value = [0, 0, 0]):
        self.__angularVelocity = [value]
    def setAngularVelocity(self, angularVelocity = [0, 0, 0]):
        self.__angularVelocity = [angularVelocity]
        return self
    def addAngularVelocity(self, angularVelocity = [0, 0, 0]):
        if self.__angularVelocity == None:            self.__angularVelocity =  []
        self.__angularVelocity +=  [angularVelocity]
        return self
    def removeAngularVelocity(self, angularVelocity):
        self.__angularVelocity = [x for x in self.__angularVelocity if x not in angularVelocity]
        return self.__angularVelocity
    def getAngularVelocity(self, angularVelocity = [0, 0, 0]):
        return self.__angularVelocity
    def angularVelocity_changed(self, angularVelocity = [0, 0, 0]):
        return self.__angularVelocity
    @property
    def autoDamp(self):
        return self.__autoDamp
    @autoDamp.setter
    def autoDamp(self, value = False):
        self.__autoDamp = [value]
    def setAutoDamp(self, autoDamp = False):
        self.__autoDamp = [autoDamp]
        return self
    def addAutoDamp(self, autoDamp = False):
        if self.__autoDamp == None:            self.__autoDamp =  []
        self.__autoDamp +=  [autoDamp]
        return self
    def removeAutoDamp(self, autoDamp):
        self.__autoDamp = [x for x in self.__autoDamp if x not in autoDamp]
        return self.__autoDamp
    def isAutoDamp(self, autoDamp = False):
        return self.__autoDamp
    @property
    def autoDisable(self):
        return self.__autoDisable
    @autoDisable.setter
    def autoDisable(self, value = False):
        self.__autoDisable = [value]
    def setAutoDisable(self, autoDisable = False):
        self.__autoDisable = [autoDisable]
        return self
    def addAutoDisable(self, autoDisable = False):
        if self.__autoDisable == None:            self.__autoDisable =  []
        self.__autoDisable +=  [autoDisable]
        return self
    def removeAutoDisable(self, autoDisable):
        self.__autoDisable = [x for x in self.__autoDisable if x not in autoDisable]
        return self.__autoDisable
    def isAutoDisable(self, autoDisable = False):
        return self.__autoDisable
    @property
    def centerOfMass(self):
        return self.__centerOfMass
    @centerOfMass.setter
    def centerOfMass(self, value = [0, 0, 0]):
        self.__centerOfMass = [value]
    def setCenterOfMass(self, centerOfMass = [0, 0, 0]):
        self.__centerOfMass = [centerOfMass]
        return self
    def addCenterOfMass(self, centerOfMass = [0, 0, 0]):
        if self.__centerOfMass == None:            self.__centerOfMass =  []
        self.__centerOfMass +=  [centerOfMass]
        return self
    def removeCenterOfMass(self, centerOfMass):
        self.__centerOfMass = [x for x in self.__centerOfMass if x not in centerOfMass]
        return self.__centerOfMass
    def getCenterOfMass(self, centerOfMass = [0, 0, 0]):
        return self.__centerOfMass
    def centerOfMass_changed(self, centerOfMass = [0, 0, 0]):
        return self.__centerOfMass
    @property
    def disableAngularSpeed(self):
        return self.__disableAngularSpeed
    @disableAngularSpeed.setter
    def disableAngularSpeed(self, value = 0):
        self.__disableAngularSpeed = [value]
    def setDisableAngularSpeed(self, disableAngularSpeed = 0):
        self.__disableAngularSpeed = [disableAngularSpeed]
        return self
    def addDisableAngularSpeed(self, disableAngularSpeed = 0):
        if self.__disableAngularSpeed == None:            self.__disableAngularSpeed =  []
        self.__disableAngularSpeed +=  [disableAngularSpeed]
        return self
    def removeDisableAngularSpeed(self, disableAngularSpeed):
        self.__disableAngularSpeed = [x for x in self.__disableAngularSpeed if x not in disableAngularSpeed]
        return self.__disableAngularSpeed
    def getDisableAngularSpeed(self, disableAngularSpeed = 0):
        return self.__disableAngularSpeed
    def disableAngularSpeed_changed(self, disableAngularSpeed = 0):
        return self.__disableAngularSpeed
    @property
    def disableLinearSpeed(self):
        return self.__disableLinearSpeed
    @disableLinearSpeed.setter
    def disableLinearSpeed(self, value = 0):
        self.__disableLinearSpeed = [value]
    def setDisableLinearSpeed(self, disableLinearSpeed = 0):
        self.__disableLinearSpeed = [disableLinearSpeed]
        return self
    def addDisableLinearSpeed(self, disableLinearSpeed = 0):
        if self.__disableLinearSpeed == None:            self.__disableLinearSpeed =  []
        self.__disableLinearSpeed +=  [disableLinearSpeed]
        return self
    def removeDisableLinearSpeed(self, disableLinearSpeed):
        self.__disableLinearSpeed = [x for x in self.__disableLinearSpeed if x not in disableLinearSpeed]
        return self.__disableLinearSpeed
    def getDisableLinearSpeed(self, disableLinearSpeed = 0):
        return self.__disableLinearSpeed
    def disableLinearSpeed_changed(self, disableLinearSpeed = 0):
        return self.__disableLinearSpeed
    @property
    def disableTime(self):
        return self.__disableTime
    @disableTime.setter
    def disableTime(self, value = 0):
        if value == None or value  <  0:
            return None
        self.__disableTime = [value]
    def setDisableTime(self, disableTime = 0):
        if disableTime == None or disableTime  <  0:
            return None
        self.__disableTime = [disableTime]
        return self
    def addDisableTime(self, disableTime = 0):
        if disableTime == None or disableTime  <  0:
            return None
        if self.__disableTime == None:            self.__disableTime =  []
        self.__disableTime +=  [disableTime]
        return self
    def removeDisableTime(self, disableTime):
        self.__disableTime = [x for x in self.__disableTime if x not in disableTime]
        return self.__disableTime
    def getDisableTime(self, disableTime = 0):
        return self.__disableTime
    def disableTime_changed(self, disableTime = 0):
        return self.__disableTime
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def finiteRotationAxis(self):
        return self.__finiteRotationAxis
    @finiteRotationAxis.setter
    def finiteRotationAxis(self, value = [0, 1, 0]):
        self.__finiteRotationAxis = [value]
    def setFiniteRotationAxis(self, finiteRotationAxis = [0, 1, 0]):
        self.__finiteRotationAxis = [finiteRotationAxis]
        return self
    def addFiniteRotationAxis(self, finiteRotationAxis = [0, 1, 0]):
        if self.__finiteRotationAxis == None:            self.__finiteRotationAxis =  []
        self.__finiteRotationAxis +=  [finiteRotationAxis]
        return self
    def removeFiniteRotationAxis(self, finiteRotationAxis):
        self.__finiteRotationAxis = [x for x in self.__finiteRotationAxis if x not in finiteRotationAxis]
        return self.__finiteRotationAxis
    def getFiniteRotationAxis(self, finiteRotationAxis = [0, 1, 0]):
        return self.__finiteRotationAxis
    def finiteRotationAxis_changed(self, finiteRotationAxis = [0, 1, 0]):
        return self.__finiteRotationAxis
    @property
    def fixed(self):
        return self.__fixed
    @fixed.setter
    def fixed(self, value = False):
        self.__fixed = [value]
    def setFixed(self, fixed = False):
        self.__fixed = [fixed]
        return self
    def addFixed(self, fixed = False):
        if self.__fixed == None:            self.__fixed =  []
        self.__fixed +=  [fixed]
        return self
    def removeFixed(self, fixed):
        self.__fixed = [x for x in self.__fixed if x not in fixed]
        return self.__fixed
    def isFixed(self, fixed = False):
        return self.__fixed
    @property
    def forces(self):
        return self.__forces
    @forces.setter
    def forces(self, value = None):
        self.__forces = [value]
    def setForces(self, forces = None):
        self.__forces = [forces]
        return self
    def addForces(self, forces = None):
        if self.__forces == None:            self.__forces =  []
        self.__forces +=  [forces]
        return self
    def removeForces(self, forces):
        self.__forces = [x for x in self.__forces if x not in forces]
        return self.__forces
    def getForces(self, forces = None):
        return self.__forces
    def forces_changed(self, forces = None):
        return self.__forces
    @property
    def geometry(self):
        return self.__geometry
    @geometry.setter
    def geometry(self, value = None):
        self.__geometry = [value]
    def setGeometry(self, geometry = None):
        self.__geometry = [geometry]
        return self
    def addGeometry(self, geometry = None):
        if self.__geometry == None:            self.__geometry =  []
        self.__geometry +=  [geometry]
        return self
    def removeGeometry(self, geometry):
        self.__geometry = [x for x in self.__geometry if x not in geometry]
        return self.__geometry
    def getGeometry(self, geometry = None):
        return self.__geometry
    def geometry_changed(self, geometry = None):
        return self.__geometry
    @property
    def inertia(self):
        return self.__inertia
    @inertia.setter
    def inertia(self, value = [1, 0, 0, 0, 1, 0, 0, 0, 1]):
        self.__inertia = [value]
    def setInertia(self, inertia = [1, 0, 0, 0, 1, 0, 0, 0, 1]):
        self.__inertia = [inertia]
        return self
    def addInertia(self, inertia = [1, 0, 0, 0, 1, 0, 0, 0, 1]):
        if self.__inertia == None:            self.__inertia =  []
        self.__inertia +=  [inertia]
        return self
    def removeInertia(self, inertia):
        self.__inertia = [x for x in self.__inertia if x not in inertia]
        return self.__inertia
    def getInertia(self, inertia = [1, 0, 0, 0, 1, 0, 0, 0, 1]):
        return self.__inertia
    def inertia_changed(self, inertia = [1, 0, 0, 0, 1, 0, 0, 0, 1]):
        return self.__inertia
    @property
    def linearDampingFactor(self):
        return self.__linearDampingFactor
    @linearDampingFactor.setter
    def linearDampingFactor(self, value = 0.001):
        self.__linearDampingFactor = [value]
    def setLinearDampingFactor(self, linearDampingFactor = 0.001):
        self.__linearDampingFactor = [linearDampingFactor]
        return self
    def addLinearDampingFactor(self, linearDampingFactor = 0.001):
        if self.__linearDampingFactor == None:            self.__linearDampingFactor =  []
        self.__linearDampingFactor +=  [linearDampingFactor]
        return self
    def removeLinearDampingFactor(self, linearDampingFactor):
        self.__linearDampingFactor = [x for x in self.__linearDampingFactor if x not in linearDampingFactor]
        return self.__linearDampingFactor
    def getLinearDampingFactor(self, linearDampingFactor = 0.001):
        return self.__linearDampingFactor
    def linearDampingFactor_changed(self, linearDampingFactor = 0.001):
        return self.__linearDampingFactor
    @property
    def linearVelocity(self):
        return self.__linearVelocity
    @linearVelocity.setter
    def linearVelocity(self, value = [0, 0, 0]):
        self.__linearVelocity = [value]
    def setLinearVelocity(self, linearVelocity = [0, 0, 0]):
        self.__linearVelocity = [linearVelocity]
        return self
    def addLinearVelocity(self, linearVelocity = [0, 0, 0]):
        if self.__linearVelocity == None:            self.__linearVelocity =  []
        self.__linearVelocity +=  [linearVelocity]
        return self
    def removeLinearVelocity(self, linearVelocity):
        self.__linearVelocity = [x for x in self.__linearVelocity if x not in linearVelocity]
        return self.__linearVelocity
    def getLinearVelocity(self, linearVelocity = [0, 0, 0]):
        return self.__linearVelocity
    def linearVelocity_changed(self, linearVelocity = [0, 0, 0]):
        return self.__linearVelocity
    @property
    def mass(self):
        return self.__mass
    @mass.setter
    def mass(self, value = 1):
        self.__mass = [value]
    def setMass(self, mass = 1):
        self.__mass = [mass]
        return self
    def addMass(self, mass = 1):
        if self.__mass == None:            self.__mass =  []
        self.__mass +=  [mass]
        return self
    def removeMass(self, mass):
        self.__mass = [x for x in self.__mass if x not in mass]
        return self.__mass
    def getMass(self, mass = 1):
        return self.__mass
    def mass_changed(self, mass = 1):
        return self.__mass
    @property
    def massDensityModel(self):
        return self.__massDensityModel
    @massDensityModel.setter
    def massDensityModel(self, value = None):
        self.__massDensityModel = [value]
    def setMassDensityModel(self, massDensityModel = None):
        self.__massDensityModel = [massDensityModel]
        return self
    def addMassDensityModel(self, massDensityModel = None):
        if self.__massDensityModel == None:            self.__massDensityModel =  []
        self.__massDensityModel +=  [massDensityModel]
        return self
    def removeMassDensityModel(self, massDensityModel):
        self.__massDensityModel = [x for x in self.__massDensityModel if x not in massDensityModel]
        return self.__massDensityModel
    def getMassDensityModel(self, massDensityModel = None):
        return self.__massDensityModel
    def massDensityModel_changed(self, massDensityModel = None):
        return self.__massDensityModel
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def orientation(self):
        return self.__orientation
    @orientation.setter
    def orientation(self, value = [0, 0, 1, 0]):
        self.__orientation = [value]
    def setOrientation(self, orientation = [0, 0, 1, 0]):
        self.__orientation = [orientation]
        return self
    def addOrientation(self, orientation = [0, 0, 1, 0]):
        if self.__orientation == None:            self.__orientation =  []
        self.__orientation +=  [orientation]
        return self
    def removeOrientation(self, orientation):
        self.__orientation = [x for x in self.__orientation if x not in orientation]
        return self.__orientation
    def getOrientation(self, orientation = [0, 0, 1, 0]):
        return self.__orientation
    def orientation_changed(self, orientation = [0, 0, 1, 0]):
        return self.__orientation
    @property
    def position(self):
        return self.__position
    @position.setter
    def position(self, value = [0, 0, 0]):
        self.__position = [value]
    def setPosition(self, position = [0, 0, 0]):
        self.__position = [position]
        return self
    def addPosition(self, position = [0, 0, 0]):
        if self.__position == None:            self.__position =  []
        self.__position +=  [position]
        return self
    def removePosition(self, position):
        self.__position = [x for x in self.__position if x not in position]
        return self.__position
    def getPosition(self, position = [0, 0, 0]):
        return self.__position
    def position_changed(self, position = [0, 0, 0]):
        return self.__position
    @property
    def torques(self):
        return self.__torques
    @torques.setter
    def torques(self, value = None):
        self.__torques = [value]
    def setTorques(self, torques = None):
        self.__torques = [torques]
        return self
    def addTorques(self, torques = None):
        if self.__torques == None:            self.__torques =  []
        self.__torques +=  [torques]
        return self
    def removeTorques(self, torques):
        self.__torques = [x for x in self.__torques if x not in torques]
        return self.__torques
    def getTorques(self, torques = None):
        return self.__torques
    def torques_changed(self, torques = None):
        return self.__torques
    @property
    def useFiniteRotation(self):
        return self.__useFiniteRotation
    @useFiniteRotation.setter
    def useFiniteRotation(self, value = False):
        self.__useFiniteRotation = [value]
    def setUseFiniteRotation(self, useFiniteRotation = False):
        self.__useFiniteRotation = [useFiniteRotation]
        return self
    def addUseFiniteRotation(self, useFiniteRotation = False):
        if self.__useFiniteRotation == None:            self.__useFiniteRotation =  []
        self.__useFiniteRotation +=  [useFiniteRotation]
        return self
    def removeUseFiniteRotation(self, useFiniteRotation):
        self.__useFiniteRotation = [x for x in self.__useFiniteRotation if x not in useFiniteRotation]
        return self.__useFiniteRotation
    def isUseFiniteRotation(self, useFiniteRotation = False):
        return self.__useFiniteRotation
    @property
    def useGlobalGravity(self):
        return self.__useGlobalGravity
    @useGlobalGravity.setter
    def useGlobalGravity(self, value = True):
        self.__useGlobalGravity = [value]
    def setUseGlobalGravity(self, useGlobalGravity = True):
        self.__useGlobalGravity = [useGlobalGravity]
        return self
    def addUseGlobalGravity(self, useGlobalGravity = True):
        if self.__useGlobalGravity == None:            self.__useGlobalGravity =  []
        self.__useGlobalGravity +=  [useGlobalGravity]
        return self
    def removeUseGlobalGravity(self, useGlobalGravity):
        self.__useGlobalGravity = [x for x in self.__useGlobalGravity if x not in useGlobalGravity]
        return self.__useGlobalGravity
    def isUseGlobalGravity(self, useGlobalGravity = True):
        return self.__useGlobalGravity
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<RigidBody'
        if self.__angularDampingFactor is not None:
            if isinstance(self.__angularDampingFactor, six.string_types):
                str += ' angularDampingFactor="'+self.__angularDampingFactor+'"'
            else:
                str += ' angularDampingFactor="'+self.__angularDampingFactor[0]+'"'
        if self.__angularVelocity is not None:
            if isinstance(self.__angularVelocity, six.string_types):
                str += ' angularVelocity="'+self.__angularVelocity+'"'
            else:
                str += ' angularVelocity="'+self.__angularVelocity[0]+'"'
        if self.__autoDamp is not None:
            if isinstance(self.__autoDamp, six.string_types):
                str += ' autoDamp="'+self.__autoDamp+'"'
            else:
                str += ' autoDamp="'+self.__autoDamp[0]+'"'
        if self.__autoDisable is not None:
            if isinstance(self.__autoDisable, six.string_types):
                str += ' autoDisable="'+self.__autoDisable+'"'
            else:
                str += ' autoDisable="'+self.__autoDisable[0]+'"'
        if self.__centerOfMass is not None:
            if isinstance(self.__centerOfMass, six.string_types):
                str += ' centerOfMass="'+self.__centerOfMass+'"'
            else:
                str += ' centerOfMass="'+self.__centerOfMass[0]+'"'
        if self.__disableAngularSpeed is not None:
            if isinstance(self.__disableAngularSpeed, six.string_types):
                str += ' disableAngularSpeed="'+self.__disableAngularSpeed+'"'
            else:
                str += ' disableAngularSpeed="'+self.__disableAngularSpeed[0]+'"'
        if self.__disableLinearSpeed is not None:
            if isinstance(self.__disableLinearSpeed, six.string_types):
                str += ' disableLinearSpeed="'+self.__disableLinearSpeed+'"'
            else:
                str += ' disableLinearSpeed="'+self.__disableLinearSpeed[0]+'"'
        if self.__disableTime is not None:
            if isinstance(self.__disableTime, six.string_types):
                str += ' disableTime="'+self.__disableTime+'"'
            else:
                str += ' disableTime="'+self.__disableTime[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__finiteRotationAxis is not None:
            if isinstance(self.__finiteRotationAxis, six.string_types):
                str += ' finiteRotationAxis="'+self.__finiteRotationAxis+'"'
            else:
                str += ' finiteRotationAxis="'+self.__finiteRotationAxis[0]+'"'
        if self.__fixed is not None:
            if isinstance(self.__fixed, six.string_types):
                str += ' fixed="'+self.__fixed+'"'
            else:
                str += ' fixed="'+self.__fixed[0]+'"'
        if self.__forces is not None:
            if isinstance(self.__forces, six.string_types):
                str += ' forces="'+self.__forces+'"'
            else:
                str += ' forces="'+self.__forces[0]+'"'
        if self.__inertia is not None:
            if isinstance(self.__inertia, six.string_types):
                str += ' inertia="'+self.__inertia+'"'
            else:
                str += ' inertia="'+self.__inertia[0]+'"'
        if self.__linearDampingFactor is not None:
            if isinstance(self.__linearDampingFactor, six.string_types):
                str += ' linearDampingFactor="'+self.__linearDampingFactor+'"'
            else:
                str += ' linearDampingFactor="'+self.__linearDampingFactor[0]+'"'
        if self.__linearVelocity is not None:
            if isinstance(self.__linearVelocity, six.string_types):
                str += ' linearVelocity="'+self.__linearVelocity+'"'
            else:
                str += ' linearVelocity="'+self.__linearVelocity[0]+'"'
        if self.__mass is not None:
            if isinstance(self.__mass, six.string_types):
                str += ' mass="'+self.__mass+'"'
            else:
                str += ' mass="'+self.__mass[0]+'"'
        if self.__orientation is not None:
            if isinstance(self.__orientation, six.string_types):
                str += ' orientation="'+self.__orientation+'"'
            else:
                str += ' orientation="'+self.__orientation[0]+'"'
        if self.__position is not None:
            if isinstance(self.__position, six.string_types):
                str += ' position="'+self.__position+'"'
            else:
                str += ' position="'+self.__position[0]+'"'
        if self.__torques is not None:
            if isinstance(self.__torques, six.string_types):
                str += ' torques="'+self.__torques+'"'
            else:
                str += ' torques="'+self.__torques[0]+'"'
        if self.__useFiniteRotation is not None:
            if isinstance(self.__useFiniteRotation, six.string_types):
                str += ' useFiniteRotation="'+self.__useFiniteRotation+'"'
            else:
                str += ' useFiniteRotation="'+self.__useFiniteRotation[0]+'"'
        if self.__useGlobalGravity is not None:
            if isinstance(self.__useGlobalGravity, six.string_types):
                str += ' useGlobalGravity="'+self.__useGlobalGravity+'"'
            else:
                str += ' useGlobalGravity="'+self.__useGlobalGravity[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<geometry'
        if self.__geometry is not None:
           for s in self.__geometry:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__geometry is not None:
           for s in self.__geometry:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</geometry>'
        str += '<massDensityModel'
        if self.__massDensityModel is not None:
           for s in self.__massDensityModel:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__massDensityModel is not None:
           for s in self.__massDensityModel:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</massDensityModel>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</RigidBody>'
        return str


class RigidBodyCollection(X3DChildNode):
    def __init__(self, **kwargs):
        super(RigidBodyCollection, self).__init__(**kwargs)
        autoDisable  = kwargs.pop("autoDisable", False)
        self.__autoDisable = autoDisable
        bodies  = kwargs.pop("bodies", None)
        self.__bodies = bodies
        collider  = kwargs.pop("collider", None)
        self.__collider = collider
        constantForceMix  = kwargs.pop("constantForceMix", 0.0001)
        self.__constantForceMix = constantForceMix
        contactSurfaceThickness  = kwargs.pop("contactSurfaceThickness", 0)
        self.__contactSurfaceThickness = contactSurfaceThickness
        disableAngularSpeed  = kwargs.pop("disableAngularSpeed", 0)
        self.__disableAngularSpeed = disableAngularSpeed
        disableLinearSpeed  = kwargs.pop("disableLinearSpeed", 0)
        self.__disableLinearSpeed = disableLinearSpeed
        disableTime  = kwargs.pop("disableTime", 0)
        if disableTime == None or disableTime  <  0:
            return None
        self.__disableTime = disableTime
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        errorCorrection  = kwargs.pop("errorCorrection", 0.8)
        self.__errorCorrection = errorCorrection
        gravity  = kwargs.pop("gravity", [0, -9.8, 0])
        self.__gravity = gravity
        iterations  = kwargs.pop("iterations", 10)
        self.__iterations = iterations
        joints  = kwargs.pop("joints", None)
        self.__joints = joints
        maxCorrectionSpeed  = kwargs.pop("maxCorrectionSpeed", -1)
        self.__maxCorrectionSpeed = maxCorrectionSpeed
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        preferAccuracy  = kwargs.pop("preferAccuracy", False)
        self.__preferAccuracy = preferAccuracy
        contacts  = kwargs.pop("contacts", None)
        self.__contacts = contacts
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def autoDisable(self):
        return self.__autoDisable
    @autoDisable.setter
    def autoDisable(self, value = False):
        self.__autoDisable = [value]
    def setAutoDisable(self, autoDisable = False):
        self.__autoDisable = [autoDisable]
        return self
    def addAutoDisable(self, autoDisable = False):
        if self.__autoDisable == None:            self.__autoDisable =  []
        self.__autoDisable +=  [autoDisable]
        return self
    def removeAutoDisable(self, autoDisable):
        self.__autoDisable = [x for x in self.__autoDisable if x not in autoDisable]
        return self.__autoDisable
    def isAutoDisable(self, autoDisable = False):
        return self.__autoDisable
    @property
    def bodies(self):
        return self.__bodies
    @bodies.setter
    def bodies(self, value = None):
        self.__bodies = [value]
    def setBodies(self, bodies = None):
        self.__bodies = [bodies]
        return self
    def addBodies(self, bodies = None):
        if self.__bodies == None:            self.__bodies =  []
        self.__bodies +=  [bodies]
        return self
    def removeBodies(self, bodies):
        self.__bodies = [x for x in self.__bodies if x not in bodies]
        return self.__bodies
    def getBodies(self, bodies = None):
        return self.__bodies
    def bodies_changed(self, bodies = None):
        return self.__bodies
    @property
    def constantForceMix(self):
        return self.__constantForceMix
    @constantForceMix.setter
    def constantForceMix(self, value = 0.0001):
        self.__constantForceMix = [value]
    def setConstantForceMix(self, constantForceMix = 0.0001):
        self.__constantForceMix = [constantForceMix]
        return self
    def addConstantForceMix(self, constantForceMix = 0.0001):
        if self.__constantForceMix == None:            self.__constantForceMix =  []
        self.__constantForceMix +=  [constantForceMix]
        return self
    def removeConstantForceMix(self, constantForceMix):
        self.__constantForceMix = [x for x in self.__constantForceMix if x not in constantForceMix]
        return self.__constantForceMix
    def getConstantForceMix(self, constantForceMix = 0.0001):
        return self.__constantForceMix
    def constantForceMix_changed(self, constantForceMix = 0.0001):
        return self.__constantForceMix
    @property
    def contactSurfaceThickness(self):
        return self.__contactSurfaceThickness
    @contactSurfaceThickness.setter
    def contactSurfaceThickness(self, value = 0):
        self.__contactSurfaceThickness = [value]
    def setContactSurfaceThickness(self, contactSurfaceThickness = 0):
        self.__contactSurfaceThickness = [contactSurfaceThickness]
        return self
    def addContactSurfaceThickness(self, contactSurfaceThickness = 0):
        if self.__contactSurfaceThickness == None:            self.__contactSurfaceThickness =  []
        self.__contactSurfaceThickness +=  [contactSurfaceThickness]
        return self
    def removeContactSurfaceThickness(self, contactSurfaceThickness):
        self.__contactSurfaceThickness = [x for x in self.__contactSurfaceThickness if x not in contactSurfaceThickness]
        return self.__contactSurfaceThickness
    def getContactSurfaceThickness(self, contactSurfaceThickness = 0):
        return self.__contactSurfaceThickness
    def contactSurfaceThickness_changed(self, contactSurfaceThickness = 0):
        return self.__contactSurfaceThickness
    @property
    def disableAngularSpeed(self):
        return self.__disableAngularSpeed
    @disableAngularSpeed.setter
    def disableAngularSpeed(self, value = 0):
        self.__disableAngularSpeed = [value]
    def setDisableAngularSpeed(self, disableAngularSpeed = 0):
        self.__disableAngularSpeed = [disableAngularSpeed]
        return self
    def addDisableAngularSpeed(self, disableAngularSpeed = 0):
        if self.__disableAngularSpeed == None:            self.__disableAngularSpeed =  []
        self.__disableAngularSpeed +=  [disableAngularSpeed]
        return self
    def removeDisableAngularSpeed(self, disableAngularSpeed):
        self.__disableAngularSpeed = [x for x in self.__disableAngularSpeed if x not in disableAngularSpeed]
        return self.__disableAngularSpeed
    def getDisableAngularSpeed(self, disableAngularSpeed = 0):
        return self.__disableAngularSpeed
    def disableAngularSpeed_changed(self, disableAngularSpeed = 0):
        return self.__disableAngularSpeed
    @property
    def disableLinearSpeed(self):
        return self.__disableLinearSpeed
    @disableLinearSpeed.setter
    def disableLinearSpeed(self, value = 0):
        self.__disableLinearSpeed = [value]
    def setDisableLinearSpeed(self, disableLinearSpeed = 0):
        self.__disableLinearSpeed = [disableLinearSpeed]
        return self
    def addDisableLinearSpeed(self, disableLinearSpeed = 0):
        if self.__disableLinearSpeed == None:            self.__disableLinearSpeed =  []
        self.__disableLinearSpeed +=  [disableLinearSpeed]
        return self
    def removeDisableLinearSpeed(self, disableLinearSpeed):
        self.__disableLinearSpeed = [x for x in self.__disableLinearSpeed if x not in disableLinearSpeed]
        return self.__disableLinearSpeed
    def getDisableLinearSpeed(self, disableLinearSpeed = 0):
        return self.__disableLinearSpeed
    def disableLinearSpeed_changed(self, disableLinearSpeed = 0):
        return self.__disableLinearSpeed
    @property
    def disableTime(self):
        return self.__disableTime
    @disableTime.setter
    def disableTime(self, value = 0):
        if value == None or value  <  0:
            return None
        self.__disableTime = [value]
    def setDisableTime(self, disableTime = 0):
        if disableTime == None or disableTime  <  0:
            return None
        self.__disableTime = [disableTime]
        return self
    def addDisableTime(self, disableTime = 0):
        if disableTime == None or disableTime  <  0:
            return None
        if self.__disableTime == None:            self.__disableTime =  []
        self.__disableTime +=  [disableTime]
        return self
    def removeDisableTime(self, disableTime):
        self.__disableTime = [x for x in self.__disableTime if x not in disableTime]
        return self.__disableTime
    def getDisableTime(self, disableTime = 0):
        return self.__disableTime
    def disableTime_changed(self, disableTime = 0):
        return self.__disableTime
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def errorCorrection(self):
        return self.__errorCorrection
    @errorCorrection.setter
    def errorCorrection(self, value = 0.8):
        self.__errorCorrection = [value]
    def setErrorCorrection(self, errorCorrection = 0.8):
        self.__errorCorrection = [errorCorrection]
        return self
    def addErrorCorrection(self, errorCorrection = 0.8):
        if self.__errorCorrection == None:            self.__errorCorrection =  []
        self.__errorCorrection +=  [errorCorrection]
        return self
    def removeErrorCorrection(self, errorCorrection):
        self.__errorCorrection = [x for x in self.__errorCorrection if x not in errorCorrection]
        return self.__errorCorrection
    def getErrorCorrection(self, errorCorrection = 0.8):
        return self.__errorCorrection
    def errorCorrection_changed(self, errorCorrection = 0.8):
        return self.__errorCorrection
    @property
    def gravity(self):
        return self.__gravity
    @gravity.setter
    def gravity(self, value = [0, -9.8, 0]):
        self.__gravity = [value]
    def setGravity(self, gravity = [0, -9.8, 0]):
        self.__gravity = [gravity]
        return self
    def addGravity(self, gravity = [0, -9.8, 0]):
        if self.__gravity == None:            self.__gravity =  []
        self.__gravity +=  [gravity]
        return self
    def removeGravity(self, gravity):
        self.__gravity = [x for x in self.__gravity if x not in gravity]
        return self.__gravity
    def getGravity(self, gravity = [0, -9.8, 0]):
        return self.__gravity
    def gravity_changed(self, gravity = [0, -9.8, 0]):
        return self.__gravity
    @property
    def iterations(self):
        return self.__iterations
    @iterations.setter
    def iterations(self, value = 10):
        self.__iterations = [value]
    def setIterations(self, iterations = 10):
        self.__iterations = [iterations]
        return self
    def addIterations(self, iterations = 10):
        if self.__iterations == None:            self.__iterations =  []
        self.__iterations +=  [iterations]
        return self
    def removeIterations(self, iterations):
        self.__iterations = [x for x in self.__iterations if x not in iterations]
        return self.__iterations
    def getIterations(self, iterations = 10):
        return self.__iterations
    def iterations_changed(self, iterations = 10):
        return self.__iterations
    @property
    def joints(self):
        return self.__joints
    @joints.setter
    def joints(self, value = None):
        self.__joints = [value]
    def setJoints(self, joints = None):
        self.__joints = [joints]
        return self
    def addJoints(self, joints = None):
        if self.__joints == None:            self.__joints =  []
        self.__joints +=  [joints]
        return self
    def removeJoints(self, joints):
        self.__joints = [x for x in self.__joints if x not in joints]
        return self.__joints
    def getJoints(self, joints = None):
        return self.__joints
    def joints_changed(self, joints = None):
        return self.__joints
    @property
    def maxCorrectionSpeed(self):
        return self.__maxCorrectionSpeed
    @maxCorrectionSpeed.setter
    def maxCorrectionSpeed(self, value = -1):
        self.__maxCorrectionSpeed = [value]
    def setMaxCorrectionSpeed(self, maxCorrectionSpeed = -1):
        self.__maxCorrectionSpeed = [maxCorrectionSpeed]
        return self
    def addMaxCorrectionSpeed(self, maxCorrectionSpeed = -1):
        if self.__maxCorrectionSpeed == None:            self.__maxCorrectionSpeed =  []
        self.__maxCorrectionSpeed +=  [maxCorrectionSpeed]
        return self
    def removeMaxCorrectionSpeed(self, maxCorrectionSpeed):
        self.__maxCorrectionSpeed = [x for x in self.__maxCorrectionSpeed if x not in maxCorrectionSpeed]
        return self.__maxCorrectionSpeed
    def getMaxCorrectionSpeed(self, maxCorrectionSpeed = -1):
        return self.__maxCorrectionSpeed
    def maxCorrectionSpeed_changed(self, maxCorrectionSpeed = -1):
        return self.__maxCorrectionSpeed
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def preferAccuracy(self):
        return self.__preferAccuracy
    @preferAccuracy.setter
    def preferAccuracy(self, value = False):
        self.__preferAccuracy = [value]
    def setPreferAccuracy(self, preferAccuracy = False):
        self.__preferAccuracy = [preferAccuracy]
        return self
    def addPreferAccuracy(self, preferAccuracy = False):
        if self.__preferAccuracy == None:            self.__preferAccuracy =  []
        self.__preferAccuracy +=  [preferAccuracy]
        return self
    def removePreferAccuracy(self, preferAccuracy):
        self.__preferAccuracy = [x for x in self.__preferAccuracy if x not in preferAccuracy]
        return self.__preferAccuracy
    def isPreferAccuracy(self, preferAccuracy = False):
        return self.__preferAccuracy
    @property
    def contacts(self):
        return self.__contacts
    @contacts.setter
    def contacts(self, value = None):
        self.__contacts = [value]
    def set_contacts(self, contacts = None):
        self.__contacts = [contacts]
        return self
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<RigidBodyCollection'
        if self.__autoDisable is not None:
            if isinstance(self.__autoDisable, six.string_types):
                str += ' autoDisable="'+self.__autoDisable+'"'
            else:
                str += ' autoDisable="'+self.__autoDisable[0]+'"'
        if self.__constantForceMix is not None:
            if isinstance(self.__constantForceMix, six.string_types):
                str += ' constantForceMix="'+self.__constantForceMix+'"'
            else:
                str += ' constantForceMix="'+self.__constantForceMix[0]+'"'
        if self.__contactSurfaceThickness is not None:
            if isinstance(self.__contactSurfaceThickness, six.string_types):
                str += ' contactSurfaceThickness="'+self.__contactSurfaceThickness+'"'
            else:
                str += ' contactSurfaceThickness="'+self.__contactSurfaceThickness[0]+'"'
        if self.__disableAngularSpeed is not None:
            if isinstance(self.__disableAngularSpeed, six.string_types):
                str += ' disableAngularSpeed="'+self.__disableAngularSpeed+'"'
            else:
                str += ' disableAngularSpeed="'+self.__disableAngularSpeed[0]+'"'
        if self.__disableLinearSpeed is not None:
            if isinstance(self.__disableLinearSpeed, six.string_types):
                str += ' disableLinearSpeed="'+self.__disableLinearSpeed+'"'
            else:
                str += ' disableLinearSpeed="'+self.__disableLinearSpeed[0]+'"'
        if self.__disableTime is not None:
            if isinstance(self.__disableTime, six.string_types):
                str += ' disableTime="'+self.__disableTime+'"'
            else:
                str += ' disableTime="'+self.__disableTime[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__errorCorrection is not None:
            if isinstance(self.__errorCorrection, six.string_types):
                str += ' errorCorrection="'+self.__errorCorrection+'"'
            else:
                str += ' errorCorrection="'+self.__errorCorrection[0]+'"'
        if self.__gravity is not None:
            if isinstance(self.__gravity, six.string_types):
                str += ' gravity="'+self.__gravity+'"'
            else:
                str += ' gravity="'+self.__gravity[0]+'"'
        if self.__iterations is not None:
            if isinstance(self.__iterations, six.string_types):
                str += ' iterations="'+self.__iterations+'"'
            else:
                str += ' iterations="'+self.__iterations[0]+'"'
        if self.__maxCorrectionSpeed is not None:
            if isinstance(self.__maxCorrectionSpeed, six.string_types):
                str += ' maxCorrectionSpeed="'+self.__maxCorrectionSpeed+'"'
            else:
                str += ' maxCorrectionSpeed="'+self.__maxCorrectionSpeed[0]+'"'
        if self.__preferAccuracy is not None:
            if isinstance(self.__preferAccuracy, six.string_types):
                str += ' preferAccuracy="'+self.__preferAccuracy+'"'
            else:
                str += ' preferAccuracy="'+self.__preferAccuracy[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<bodies'
        if self.__bodies is not None:
           for s in self.__bodies:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__bodies is not None:
           for s in self.__bodies:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</bodies>'
        str += '<collider'
        if self.__collider is not None:
           for s in self.__collider:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__collider is not None:
           for s in self.__collider:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</collider>'
        str += '<joints'
        if self.__joints is not None:
           for s in self.__joints:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__joints is not None:
           for s in self.__joints:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</joints>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<contacts'
        if self.__contacts is not None:
           for s in self.__contacts:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__contacts is not None:
           for s in self.__contacts:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</contacts>'
        str += '</RigidBodyCollection>'
        return str


class ScalarChaser(X3DChaserNode):
    def __init__(self, **kwargs):
        super(ScalarChaser, self).__init__(**kwargs)
        duration  = kwargs.pop("duration", 1)
        if duration == None or duration  <  0:
            return None
        self.__duration = duration
        initialDestination  = kwargs.pop("initialDestination", 0)
        self.__initialDestination = initialDestination
        initialValue  = kwargs.pop("initialValue", 0)
        self.__initialValue = initialValue
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        destination  = kwargs.pop("destination", None)
        self.__destination = destination
        value  = kwargs.pop("value", None)
        self.__value = value
        value_changed  = kwargs.pop("value_changed", None)
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def isActive(self, Active = None):
        return self.__Active
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def destination(self):
        return self.__destination
    @destination.setter
    def destination(self, value = None):
        self.__destination = [value]
    def set_destination(self, destination = None):
        self.__destination = [destination]
        return self
    @property
    def value(self):
        return self.__value
    @value.setter
    def value(self, value = None):
        self.__value = [value]
    def set_value(self, value = None):
        self.__value = [value]
        return self
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ScalarChaser'
        if self.__duration is not None:
            if isinstance(self.__duration, six.string_types):
                str += ' duration="'+self.__duration+'"'
            else:
                str += ' duration="'+self.__duration[0]+'"'
        if self.__initialDestination is not None:
            if isinstance(self.__initialDestination, six.string_types):
                str += ' initialDestination="'+self.__initialDestination+'"'
            else:
                str += ' initialDestination="'+self.__initialDestination[0]+'"'
        if self.__initialValue is not None:
            if isinstance(self.__initialValue, six.string_types):
                str += ' initialValue="'+self.__initialValue+'"'
            else:
                str += ' initialValue="'+self.__initialValue[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__destination is not None:
            if isinstance(self.__destination, six.string_types):
                str += ' destination="'+self.__destination+'"'
            else:
                str += ' destination="'+self.__destination[0]+'"'
        if self.__value is not None:
            if isinstance(self.__value, six.string_types):
                str += ' value="'+self.__value+'"'
            else:
                str += ' value="'+self.__value[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</ScalarChaser>'
        return str


class ScalarDamper(X3DDamperNode):
    def __init__(self, **kwargs):
        super(ScalarDamper, self).__init__(**kwargs)
        initialDestination  = kwargs.pop("initialDestination", 0)
        self.__initialDestination = initialDestination
        initialValue  = kwargs.pop("initialValue", 0)
        self.__initialValue = initialValue
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        order  = kwargs.pop("order", 3)
        if order == None or order  <  0:
            return None
        if order == None or order  >  5:
            return None
        self.__order = order
        destination  = kwargs.pop("destination", None)
        self.__destination = destination
        value  = kwargs.pop("value", None)
        self.__value = value
        tau  = kwargs.pop("tau", 0.3)
        if tau == None or tau  <  0:
            return None
        self.__tau = tau
        tolerance  = kwargs.pop("tolerance", -1)
        self.__tolerance = tolerance
        value_changed  = kwargs.pop("value_changed", None)
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def isActive(self, Active = None):
        return self.__Active
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def destination(self):
        return self.__destination
    @destination.setter
    def destination(self, value = None):
        self.__destination = [value]
    def set_destination(self, destination = None):
        self.__destination = [destination]
        return self
    @property
    def value(self):
        return self.__value
    @value.setter
    def value(self, value = None):
        self.__value = [value]
    def set_value(self, value = None):
        self.__value = [value]
        return self
    @property
    def tau(self):
        return self.__tau
    @tau.setter
    def tau(self, value = 0.3):
        if value == None or value  <  0:
            return None
        self.__tau = [value]
    def setTau(self, tau = 0.3):
        if tau == None or tau  <  0:
            return None
        self.__tau = [tau]
        return self
    def addTau(self, tau = 0.3):
        if tau == None or tau  <  0:
            return None
        if self.__tau == None:            self.__tau =  []
        self.__tau +=  [tau]
        return self
    def removeTau(self, tau):
        self.__tau = [x for x in self.__tau if x not in tau]
        return self.__tau
    def getTau(self, tau = 0.3):
        return self.__tau
    def tau_changed(self, tau = 0.3):
        return self.__tau
    @property
    def tolerance(self):
        return self.__tolerance
    @tolerance.setter
    def tolerance(self, value = -1):
        self.__tolerance = [value]
    def setTolerance(self, tolerance = -1):
        self.__tolerance = [tolerance]
        return self
    def addTolerance(self, tolerance = -1):
        if self.__tolerance == None:            self.__tolerance =  []
        self.__tolerance +=  [tolerance]
        return self
    def removeTolerance(self, tolerance):
        self.__tolerance = [x for x in self.__tolerance if x not in tolerance]
        return self.__tolerance
    def getTolerance(self, tolerance = -1):
        return self.__tolerance
    def tolerance_changed(self, tolerance = -1):
        return self.__tolerance
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ScalarDamper'
        if self.__initialDestination is not None:
            if isinstance(self.__initialDestination, six.string_types):
                str += ' initialDestination="'+self.__initialDestination+'"'
            else:
                str += ' initialDestination="'+self.__initialDestination[0]+'"'
        if self.__initialValue is not None:
            if isinstance(self.__initialValue, six.string_types):
                str += ' initialValue="'+self.__initialValue+'"'
            else:
                str += ' initialValue="'+self.__initialValue[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__order is not None:
            if isinstance(self.__order, six.string_types):
                str += ' order="'+self.__order+'"'
            else:
                str += ' order="'+self.__order[0]+'"'
        if self.__destination is not None:
            if isinstance(self.__destination, six.string_types):
                str += ' destination="'+self.__destination+'"'
            else:
                str += ' destination="'+self.__destination[0]+'"'
        if self.__value is not None:
            if isinstance(self.__value, six.string_types):
                str += ' value="'+self.__value+'"'
            else:
                str += ' value="'+self.__value[0]+'"'
        if self.__tau is not None:
            if isinstance(self.__tau, six.string_types):
                str += ' tau="'+self.__tau+'"'
            else:
                str += ' tau="'+self.__tau[0]+'"'
        if self.__tolerance is not None:
            if isinstance(self.__tolerance, six.string_types):
                str += ' tolerance="'+self.__tolerance+'"'
            else:
                str += ' tolerance="'+self.__tolerance[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</ScalarDamper>'
        return str


class ScalarInterpolator(X3DInterpolatorNode):
    def __init__(self, **kwargs):
        super(ScalarInterpolator, self).__init__(**kwargs)
        key  = kwargs.pop("key", None)
        self.__key = key
        keyValue  = kwargs.pop("keyValue", None)
        self.__keyValue = keyValue
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        fraction  = kwargs.pop("fraction", None)
        self.__fraction = fraction
        value_changed  = kwargs.pop("value_changed", None)
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def key(self):
        return self.__key
    @key.setter
    def key(self, value = None):
        self.__key = [value]
    def setKey(self, key = None):
        self.__key = [key]
        return self
    def addKey(self, key = None):
        if self.__key == None:            self.__key =  []
        self.__key +=  [key]
        return self
    def removeKey(self, key):
        self.__key = [x for x in self.__key if x not in key]
        return self.__key
    def getKey(self, key = None):
        return self.__key
    def key_changed(self, key = None):
        return self.__key
    @property
    def keyValue(self):
        return self.__keyValue
    @keyValue.setter
    def keyValue(self, value = None):
        self.__keyValue = [value]
    def setKeyValue(self, keyValue = None):
        self.__keyValue = [keyValue]
        return self
    def addKeyValue(self, keyValue = None):
        if self.__keyValue == None:            self.__keyValue =  []
        self.__keyValue +=  [keyValue]
        return self
    def removeKeyValue(self, keyValue):
        self.__keyValue = [x for x in self.__keyValue if x not in keyValue]
        return self.__keyValue
    def getKeyValue(self, keyValue = None):
        return self.__keyValue
    def keyValue_changed(self, keyValue = None):
        return self.__keyValue
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def fraction(self):
        return self.__fraction
    @fraction.setter
    def fraction(self, value = None):
        self.__fraction = [value]
    def set_fraction(self, fraction = None):
        self.__fraction = [fraction]
        return self
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ScalarInterpolator'
        if self.__key is not None:
            if isinstance(self.__key, six.string_types):
                str += ' key="'+self.__key+'"'
            else:
                str += ' key="'+self.__key[0]+'"'
        if self.__keyValue is not None:
            if isinstance(self.__keyValue, six.string_types):
                str += ' keyValue="'+self.__keyValue+'"'
            else:
                str += ' keyValue="'+self.__keyValue[0]+'"'
        if self.__fraction is not None:
            if isinstance(self.__fraction, six.string_types):
                str += ' fraction="'+self.__fraction+'"'
            else:
                str += ' fraction="'+self.__fraction[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</ScalarInterpolator>'
        return str


class ScreenFontStyle(X3DFontStyleNode):
    def __init__(self, **kwargs):
        super(ScreenFontStyle, self).__init__(**kwargs)
        family  = kwargs.pop("family", ["SERIF"])
        self.__family = family
        horizontal  = kwargs.pop("horizontal", True)
        self.__horizontal = horizontal
        justify  = kwargs.pop("justify", ["BEGIN"])
        if '"MIDDLE"' == justify:
            pass
        elif '"MIDDLE" "BEGIN"' == justify:
            pass
        elif '"MIDDLE" "END"' == justify:
            pass
        elif '"MIDDLE" "FIRST"' == justify:
            pass
        elif '"MIDDLE" "MIDDLE"' == justify:
            pass
        elif '"BEGIN"' == justify:
            pass
        elif '"BEGIN" "BEGIN"' == justify:
            pass
        elif '"BEGIN" "END"' == justify:
            pass
        elif '"BEGIN" "FIRST"' == justify:
            pass
        elif '"BEGIN" "MIDDLE"' == justify:
            pass
        elif '"END"' == justify:
            pass
        elif '"END" "BEGIN"' == justify:
            pass
        elif '"END" "END"' == justify:
            pass
        elif '"END" "FIRST"' == justify:
            pass
        elif '"END" "MIDDLE"' == justify:
            pass
        elif '"FIRST"' == justify:
            pass
        elif '"FIRST" "BEGIN"' == justify:
            pass
        elif '"FIRST" "END"' == justify:
            pass
        elif '"FIRST" "FIRST"' == justify:
            pass
        elif '"FIRST" "MIDDLE"' == justify:
            pass
        else:
            return None
        self.__justify = justify
        language  = kwargs.pop("language", None)
        self.__language = language
        leftToRight  = kwargs.pop("leftToRight", True)
        self.__leftToRight = leftToRight
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        pointSize  = kwargs.pop("pointSize", 12.0)
        if pointSize == None or pointSize  <=  0:
            return None
        self.__pointSize = pointSize
        spacing  = kwargs.pop("spacing", 1.0)
        if spacing == None or spacing  <  0:
            return None
        self.__spacing = spacing
        style  = kwargs.pop("style", "PLAIN")
        if 'PLAIN' == style:
            pass
        elif 'BOLD' == style:
            pass
        elif 'ITALIC' == style:
            pass
        elif 'BOLDITALIC' == style:
            pass
        else:
            return None
        self.__style = style
        topToBottom  = kwargs.pop("topToBottom", True)
        self.__topToBottom = topToBottom
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ScreenFontStyle'
        if self.__family is not None:
            if isinstance(self.__family, six.string_types):
                str += ' family="'+self.__family+'"'
            else:
                str += ' family="'+self.__family[0]+'"'
        if self.__horizontal is not None:
            if isinstance(self.__horizontal, six.string_types):
                str += ' horizontal="'+self.__horizontal+'"'
            else:
                str += ' horizontal="'+self.__horizontal[0]+'"'
        if self.__justify is not None:
            if isinstance(self.__justify, six.string_types):
                str += ' justify="'+self.__justify+'"'
            else:
                str += ' justify="'+self.__justify[0]+'"'
        if self.__language is not None:
            if isinstance(self.__language, six.string_types):
                str += ' language="'+self.__language+'"'
            else:
                str += ' language="'+self.__language[0]+'"'
        if self.__leftToRight is not None:
            if isinstance(self.__leftToRight, six.string_types):
                str += ' leftToRight="'+self.__leftToRight+'"'
            else:
                str += ' leftToRight="'+self.__leftToRight[0]+'"'
        if self.__pointSize is not None:
            if isinstance(self.__pointSize, six.string_types):
                str += ' pointSize="'+self.__pointSize+'"'
            else:
                str += ' pointSize="'+self.__pointSize[0]+'"'
        if self.__spacing is not None:
            if isinstance(self.__spacing, six.string_types):
                str += ' spacing="'+self.__spacing+'"'
            else:
                str += ' spacing="'+self.__spacing[0]+'"'
        if self.__style is not None:
            if isinstance(self.__style, six.string_types):
                str += ' style="'+self.__style+'"'
            else:
                str += ' style="'+self.__style[0]+'"'
        if self.__topToBottom is not None:
            if isinstance(self.__topToBottom, six.string_types):
                str += ' topToBottom="'+self.__topToBottom+'"'
            else:
                str += ' topToBottom="'+self.__topToBottom[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</ScreenFontStyle>'
        return str


class ScreenGroup(X3DGroupingNode):
    def __init__(self, **kwargs):
        super(ScreenGroup, self).__init__(**kwargs)
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        children  = kwargs.pop("children", None)
        self.__children = children
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    def addChildren(self, Children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [Children]
        return self
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ScreenGroup'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '</ScreenGroup>'
        return str


class Script(X3DScriptNode):
    def __init__(self, **kwargs):
        super(Script, self).__init__(**kwargs)
        directOutput  = kwargs.pop("directOutput", False)
        self.__directOutput = directOutput
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        mustEvaluate  = kwargs.pop("mustEvaluate", False)
        self.__mustEvaluate = mustEvaluate
        url  = kwargs.pop("url", None)
        self.__url = url
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
        field  = kwargs.pop("field", None)
        self.__field = field
        IS  = kwargs.pop("IS", None)
        self.__IS = IS
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def url(self):
        return self.__url
    @url.setter
    def url(self, value = None):
        self.__url = [value]
    def setUrl(self, url = None):
        self.__url = [url]
        return self
    def addUrl(self, url = None):
        if self.__url == None:            self.__url =  []
        self.__url +=  [url]
        return self
    def removeUrl(self, url):
        self.__url = [x for x in self.__url if x not in url]
        return self.__url
    def getUrl(self, url = None):
        return self.__url
    def url_changed(self, url = None):
        return self.__url
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    @property
    def sourceCode(self):
        return self.__sourceCode
    @sourceCode.setter
    def sourceCode(self, value = None):
        self.__sourceCode = [value]
    def setSourceCode(self, sourceCode = None):
        self.__sourceCode = [sourceCode]
        return self
    def addSourceCode(self, sourceCode = None):
        if self.__sourceCode == None:            self.__sourceCode =  []
        self.__sourceCode +=  [sourceCode]
        return self
    @property
    def field(self):
        return self.__field
    @field.setter
    def field(self, value = None):
        self.__field = [value]
    def setField(self, field = None):
        self.__field = [field]
        return self
    def addField(self, field = None):
        if self.__field == None:            self.__field =  []
        self.__field +=  [field]
        return self
    def removeField(self, field):
        self.__field = [x for x in self.__field if x not in field]
        return self.__field
    def getField(self, field = None):
        return self.__field
    def field_changed(self, field = None):
        return self.__field
    @property
    def IS(self):
        return self.__IS
    @IS.setter
    def IS(self, value = None):
        self.__IS = [value]
    def setIS(self, IS = None):
        self.__IS = [IS]
        return self
    def addIS(self, IS = None):
        if self.__IS == None:            self.__IS =  []
        self.__IS +=  [IS]
        return self
    def removeIS(self, IS):
        self.__IS = [x for x in self.__IS if x not in IS]
        return self.__IS
    def getIS(self, IS = None):
        return self.__IS
    def IS_changed(self, IS = None):
        return self.__IS
    def toXML(self):
        str = ''
        str += '<Script'
        if self.__directOutput is not None:
            if isinstance(self.__directOutput, six.string_types):
                str += ' directOutput="'+self.__directOutput+'"'
            else:
                str += ' directOutput="'+self.__directOutput[0]+'"'
        if self.__mustEvaluate is not None:
            if isinstance(self.__mustEvaluate, six.string_types):
                str += ' mustEvaluate="'+self.__mustEvaluate+'"'
            else:
                str += ' mustEvaluate="'+self.__mustEvaluate[0]+'"'
        if self.__url is not None:
            if isinstance(self.__url, six.string_types):
                str += ' url="'+self.__url+'"'
            else:
                str += ' url="'+self.__url[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</Script>'
        return str


class SegmentedVolumeData(X3DVolumeDataNode):
    def __init__(self, **kwargs):
        super(SegmentedVolumeData, self).__init__(**kwargs)
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        dimensions  = kwargs.pop("dimensions", [1, 1, 1])
        if dimensions == None or len(dimensions) <= 0 or min(dimensions)  <=  0:
            return None
        self.__dimensions = dimensions
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        renderStyle  = kwargs.pop("renderStyle", None)
        self.__renderStyle = renderStyle
        segmentEnabled  = kwargs.pop("segmentEnabled", None)
        self.__segmentEnabled = segmentEnabled
        segmentIdentifiers  = kwargs.pop("segmentIdentifiers", None)
        self.__segmentIdentifiers = segmentIdentifiers
        voxels  = kwargs.pop("voxels", None)
        self.__voxels = voxels
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def dimensions(self):
        return self.__dimensions
    @dimensions.setter
    def dimensions(self, value = [1, 1, 1]):
        if value == None or len(value) <= 0 or min(value)  <=  0:
            return None
        self.__dimensions = [value]
    def setDimensions(self, dimensions = [1, 1, 1]):
        if dimensions == None or len(dimensions) <= 0 or min(dimensions)  <=  0:
            return None
        self.__dimensions = [dimensions]
        return self
    def addDimensions(self, dimensions = [1, 1, 1]):
        if dimensions == None or len(dimensions) <= 0 or min(dimensions)  <=  0:
            return None
        if self.__dimensions == None:            self.__dimensions =  []
        self.__dimensions +=  [dimensions]
        return self
    def removeDimensions(self, dimensions):
        self.__dimensions = [x for x in self.__dimensions if x not in dimensions]
        return self.__dimensions
    def getDimensions(self, dimensions = [1, 1, 1]):
        return self.__dimensions
    def dimensions_changed(self, dimensions = [1, 1, 1]):
        return self.__dimensions
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def renderStyle(self):
        return self.__renderStyle
    @renderStyle.setter
    def renderStyle(self, value = None):
        self.__renderStyle = [value]
    def setRenderStyle(self, renderStyle = None):
        self.__renderStyle = [renderStyle]
        return self
    def addRenderStyle(self, renderStyle = None):
        if self.__renderStyle == None:            self.__renderStyle =  []
        self.__renderStyle +=  [renderStyle]
        return self
    def removeRenderStyle(self, renderStyle):
        self.__renderStyle = [x for x in self.__renderStyle if x not in renderStyle]
        return self.__renderStyle
    def getRenderStyle(self, renderStyle = None):
        return self.__renderStyle
    def renderStyle_changed(self, renderStyle = None):
        return self.__renderStyle
    @property
    def segmentEnabled(self):
        return self.__segmentEnabled
    @segmentEnabled.setter
    def segmentEnabled(self, value = None):
        self.__segmentEnabled = [value]
    def setSegmentEnabled(self, segmentEnabled = None):
        self.__segmentEnabled = [segmentEnabled]
        return self
    def addSegmentEnabled(self, segmentEnabled = None):
        if self.__segmentEnabled == None:            self.__segmentEnabled =  []
        self.__segmentEnabled +=  [segmentEnabled]
        return self
    def removeSegmentEnabled(self, segmentEnabled):
        self.__segmentEnabled = [x for x in self.__segmentEnabled if x not in segmentEnabled]
        return self.__segmentEnabled
    def getSegmentEnabled(self, segmentEnabled = None):
        return self.__segmentEnabled
    def segmentEnabled_changed(self, segmentEnabled = None):
        return self.__segmentEnabled
    @property
    def segmentIdentifiers(self):
        return self.__segmentIdentifiers
    @segmentIdentifiers.setter
    def segmentIdentifiers(self, value = None):
        self.__segmentIdentifiers = [value]
    def setSegmentIdentifiers(self, segmentIdentifiers = None):
        self.__segmentIdentifiers = [segmentIdentifiers]
        return self
    def addSegmentIdentifiers(self, segmentIdentifiers = None):
        if self.__segmentIdentifiers == None:            self.__segmentIdentifiers =  []
        self.__segmentIdentifiers +=  [segmentIdentifiers]
        return self
    def removeSegmentIdentifiers(self, segmentIdentifiers):
        self.__segmentIdentifiers = [x for x in self.__segmentIdentifiers if x not in segmentIdentifiers]
        return self.__segmentIdentifiers
    def getSegmentIdentifiers(self, segmentIdentifiers = None):
        return self.__segmentIdentifiers
    def segmentIdentifiers_changed(self, segmentIdentifiers = None):
        return self.__segmentIdentifiers
    @property
    def voxels(self):
        return self.__voxels
    @voxels.setter
    def voxels(self, value = None):
        self.__voxels = [value]
    def setVoxels(self, voxels = None):
        self.__voxels = [voxels]
        return self
    def addVoxels(self, voxels = None):
        if self.__voxels == None:            self.__voxels =  []
        self.__voxels +=  [voxels]
        return self
    def removeVoxels(self, voxels):
        self.__voxels = [x for x in self.__voxels if x not in voxels]
        return self.__voxels
    def getVoxels(self, voxels = None):
        return self.__voxels
    def voxels_changed(self, voxels = None):
        return self.__voxels
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<SegmentedVolumeData'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__dimensions is not None:
            if isinstance(self.__dimensions, six.string_types):
                str += ' dimensions="'+self.__dimensions+'"'
            else:
                str += ' dimensions="'+self.__dimensions[0]+'"'
        if self.__segmentEnabled is not None:
            if isinstance(self.__segmentEnabled, six.string_types):
                str += ' segmentEnabled="'+self.__segmentEnabled+'"'
            else:
                str += ' segmentEnabled="'+self.__segmentEnabled[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<renderStyle'
        if self.__renderStyle is not None:
           for s in self.__renderStyle:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__renderStyle is not None:
           for s in self.__renderStyle:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</renderStyle>'
        str += '<segmentIdentifiers'
        if self.__segmentIdentifiers is not None:
           for s in self.__segmentIdentifiers:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__segmentIdentifiers is not None:
           for s in self.__segmentIdentifiers:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</segmentIdentifiers>'
        str += '<voxels'
        if self.__voxels is not None:
           for s in self.__voxels:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__voxels is not None:
           for s in self.__voxels:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</voxels>'
        str += '</SegmentedVolumeData>'
        return str


class ShadedVolumeStyle(X3DComposableVolumeRenderStyleNode):
    def __init__(self, **kwargs):
        super(ShadedVolumeStyle, self).__init__(**kwargs)
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        lighting  = kwargs.pop("lighting", False)
        self.__lighting = lighting
        material  = kwargs.pop("material", None)
        self.__material = material
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        phaseFunction  = kwargs.pop("phaseFunction", "Henyey-Greenstein")
        self.__phaseFunction = phaseFunction
        shadows  = kwargs.pop("shadows", False)
        self.__shadows = shadows
        surfaceNormals  = kwargs.pop("surfaceNormals", None)
        self.__surfaceNormals = surfaceNormals
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def lighting(self):
        return self.__lighting
    @lighting.setter
    def lighting(self, value = False):
        self.__lighting = [value]
    def setLighting(self, lighting = False):
        self.__lighting = [lighting]
        return self
    def addLighting(self, lighting = False):
        if self.__lighting == None:            self.__lighting =  []
        self.__lighting +=  [lighting]
        return self
    def removeLighting(self, lighting):
        self.__lighting = [x for x in self.__lighting if x not in lighting]
        return self.__lighting
    def isLighting(self, lighting = False):
        return self.__lighting
    @property
    def material(self):
        return self.__material
    @material.setter
    def material(self, value = None):
        self.__material = [value]
    def setMaterial(self, material = None):
        self.__material = [material]
        return self
    def addMaterial(self, material = None):
        if self.__material == None:            self.__material =  []
        self.__material +=  [material]
        return self
    def removeMaterial(self, material):
        self.__material = [x for x in self.__material if x not in material]
        return self.__material
    def getMaterial(self, material = None):
        return self.__material
    def material_changed(self, material = None):
        return self.__material
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def shadows(self):
        return self.__shadows
    @shadows.setter
    def shadows(self, value = False):
        self.__shadows = [value]
    def setShadows(self, shadows = False):
        self.__shadows = [shadows]
        return self
    def addShadows(self, shadows = False):
        if self.__shadows == None:            self.__shadows =  []
        self.__shadows +=  [shadows]
        return self
    def removeShadows(self, shadows):
        self.__shadows = [x for x in self.__shadows if x not in shadows]
        return self.__shadows
    def isShadows(self, shadows = False):
        return self.__shadows
    @property
    def surfaceNormals(self):
        return self.__surfaceNormals
    @surfaceNormals.setter
    def surfaceNormals(self, value = None):
        self.__surfaceNormals = [value]
    def setSurfaceNormals(self, surfaceNormals = None):
        self.__surfaceNormals = [surfaceNormals]
        return self
    def addSurfaceNormals(self, surfaceNormals = None):
        if self.__surfaceNormals == None:            self.__surfaceNormals =  []
        self.__surfaceNormals +=  [surfaceNormals]
        return self
    def removeSurfaceNormals(self, surfaceNormals):
        self.__surfaceNormals = [x for x in self.__surfaceNormals if x not in surfaceNormals]
        return self.__surfaceNormals
    def getSurfaceNormals(self, surfaceNormals = None):
        return self.__surfaceNormals
    def surfaceNormals_changed(self, surfaceNormals = None):
        return self.__surfaceNormals
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ShadedVolumeStyle'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__lighting is not None:
            if isinstance(self.__lighting, six.string_types):
                str += ' lighting="'+self.__lighting+'"'
            else:
                str += ' lighting="'+self.__lighting[0]+'"'
        if self.__phaseFunction is not None:
            if isinstance(self.__phaseFunction, six.string_types):
                str += ' phaseFunction="'+self.__phaseFunction+'"'
            else:
                str += ' phaseFunction="'+self.__phaseFunction[0]+'"'
        if self.__shadows is not None:
            if isinstance(self.__shadows, six.string_types):
                str += ' shadows="'+self.__shadows+'"'
            else:
                str += ' shadows="'+self.__shadows[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<material'
        if self.__material is not None:
           for s in self.__material:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__material is not None:
           for s in self.__material:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</material>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<surfaceNormals'
        if self.__surfaceNormals is not None:
           for s in self.__surfaceNormals:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__surfaceNormals is not None:
           for s in self.__surfaceNormals:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</surfaceNormals>'
        str += '</ShadedVolumeStyle>'
        return str


class ShaderPart(X3DUrlObject, X3DNode):
    def __init__(self, **kwargs):
        super(ShaderPart, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        type  = kwargs.pop("type", "VERTEX")
        self.__type = type
        url  = kwargs.pop("url", None)
        self.__url = url
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def type(self):
        return self.__type
    @type.setter
    def type(self, value = "VERTEX"):
        self.__type = [value]
    def setType(self, type = "VERTEX"):
        self.__type = [type]
        return self
    def addType(self, type = "VERTEX"):
        if self.__type == None:            self.__type =  []
        self.__type +=  [type]
        return self
    def removeType(self, type):
        self.__type = [x for x in self.__type if x not in type]
        return self.__type
    def getType(self, type = "VERTEX"):
        return self.__type
    def type_changed(self, type = "VERTEX"):
        return self.__type
    @property
    def url(self):
        return self.__url
    @url.setter
    def url(self, value = None):
        self.__url = [value]
    def setUrl(self, url = None):
        self.__url = [url]
        return self
    def addUrl(self, url = None):
        if self.__url == None:            self.__url =  []
        self.__url +=  [url]
        return self
    def removeUrl(self, url):
        self.__url = [x for x in self.__url if x not in url]
        return self.__url
    def getUrl(self, url = None):
        return self.__url
    def url_changed(self, url = None):
        return self.__url
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    @property
    def IS(self):
        return self.__IS
    @IS.setter
    def IS(self, value = None):
        self.__IS = [value]
    def setIS(self, IS = None):
        self.__IS = [IS]
        return self
    def addIS(self, IS = None):
        if self.__IS == None:            self.__IS =  []
        self.__IS +=  [IS]
        return self
    def removeIS(self, IS):
        self.__IS = [x for x in self.__IS if x not in IS]
        return self.__IS
    def getIS(self, IS = None):
        return self.__IS
    def IS_changed(self, IS = None):
        return self.__IS
    def toXML(self):
        str = ''
        str += '<ShaderPart'
        if self.__type is not None:
            if isinstance(self.__type, six.string_types):
                str += ' type="'+self.__type+'"'
            else:
                str += ' type="'+self.__type[0]+'"'
        if self.__url is not None:
            if isinstance(self.__url, six.string_types):
                str += ' url="'+self.__url+'"'
            else:
                str += ' url="'+self.__url[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</ShaderPart>'
        return str


class ShaderProgram(X3DUrlObject, X3DProgrammableShaderObject, X3DNode):
    def __init__(self, **kwargs):
        super(ShaderProgram, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        type  = kwargs.pop("type", "VERTEX")
        self.__type = type
        url  = kwargs.pop("url", None)
        self.__url = url
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def type(self):
        return self.__type
    @type.setter
    def type(self, value = "VERTEX"):
        self.__type = [value]
    def setType(self, type = "VERTEX"):
        self.__type = [type]
        return self
    def addType(self, type = "VERTEX"):
        if self.__type == None:            self.__type =  []
        self.__type +=  [type]
        return self
    def removeType(self, type):
        self.__type = [x for x in self.__type if x not in type]
        return self.__type
    def getType(self, type = "VERTEX"):
        return self.__type
    def type_changed(self, type = "VERTEX"):
        return self.__type
    @property
    def url(self):
        return self.__url
    @url.setter
    def url(self, value = None):
        self.__url = [value]
    def setUrl(self, url = None):
        self.__url = [url]
        return self
    def addUrl(self, url = None):
        if self.__url == None:            self.__url =  []
        self.__url +=  [url]
        return self
    def removeUrl(self, url):
        self.__url = [x for x in self.__url if x not in url]
        return self.__url
    def getUrl(self, url = None):
        return self.__url
    def url_changed(self, url = None):
        return self.__url
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ShaderProgram'
        if self.__type is not None:
            if isinstance(self.__type, six.string_types):
                str += ' type="'+self.__type+'"'
            else:
                str += ' type="'+self.__type[0]+'"'
        if self.__url is not None:
            if isinstance(self.__url, six.string_types):
                str += ' url="'+self.__url+'"'
            else:
                str += ' url="'+self.__url[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</ShaderProgram>'
        return str


class Shape(X3DShapeNode):
    def __init__(self, **kwargs):
        super(Shape, self).__init__(**kwargs)
        appearance  = kwargs.pop("appearance", None)
        self.__appearance = appearance
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        geometry  = kwargs.pop("geometry", None)
        self.__geometry = geometry
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def appearance(self):
        return self.__appearance
    @appearance.setter
    def appearance(self, value = None):
        self.__appearance = [value]
    def setAppearance(self, appearance = None):
        self.__appearance = [appearance]
        return self
    def addAppearance(self, appearance = None):
        if self.__appearance == None:            self.__appearance =  []
        self.__appearance +=  [appearance]
        return self
    def removeAppearance(self, appearance):
        self.__appearance = [x for x in self.__appearance if x not in appearance]
        return self.__appearance
    def getAppearance(self, appearance = None):
        return self.__appearance
    def appearance_changed(self, appearance = None):
        return self.__appearance
    @property
    def geometry(self):
        return self.__geometry
    @geometry.setter
    def geometry(self, value = None):
        self.__geometry = [value]
    def setGeometry(self, geometry = None):
        self.__geometry = [geometry]
        return self
    def addGeometry(self, geometry = None):
        if self.__geometry == None:            self.__geometry =  []
        self.__geometry +=  [geometry]
        return self
    def removeGeometry(self, geometry):
        self.__geometry = [x for x in self.__geometry if x not in geometry]
        return self.__geometry
    def getGeometry(self, geometry = None):
        return self.__geometry
    def geometry_changed(self, geometry = None):
        return self.__geometry
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    @property
    def IS(self):
        return self.__IS
    @IS.setter
    def IS(self, value = None):
        self.__IS = [value]
    def setIS(self, IS = None):
        self.__IS = [IS]
        return self
    def addIS(self, IS = None):
        if self.__IS == None:            self.__IS =  []
        self.__IS +=  [IS]
        return self
    def removeIS(self, IS):
        self.__IS = [x for x in self.__IS if x not in IS]
        return self.__IS
    def getIS(self, IS = None):
        return self.__IS
    def IS_changed(self, IS = None):
        return self.__IS
    def toXML(self):
        str = ''
        str += '<Shape'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<appearance'
        if self.__appearance is not None:
           for s in self.__appearance:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__appearance is not None:
           for s in self.__appearance:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</appearance>'
        str += '<geometry'
        if self.__geometry is not None:
           for s in self.__geometry:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__geometry is not None:
           for s in self.__geometry:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</geometry>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</Shape>'
        return str


class SignalPdu(X3DBoundedObject, X3DNetworkSensorNode):
    def __init__(self, **kwargs):
        super(SignalPdu, self).__init__(**kwargs)
        address  = kwargs.pop("address", "localhost")
        self.__address = address
        applicationID  = kwargs.pop("applicationID", 0)
        self.__applicationID = applicationID
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        data  = kwargs.pop("data", None)
        self.__data = data
        dataLength  = kwargs.pop("dataLength", 0)
        self.__dataLength = dataLength
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        encodingScheme  = kwargs.pop("encodingScheme", 0)
        self.__encodingScheme = encodingScheme
        entityID  = kwargs.pop("entityID", 0)
        self.__entityID = entityID
        geoCoords  = kwargs.pop("geoCoords", [0, 0, 0])
        self.__geoCoords = geoCoords
        geoSystem  = kwargs.pop("geoSystem", ["GD", "WE"])
        self.__geoSystem = geoSystem
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        NetworkReader  = kwargs.pop("NetworkReader", None)
        self.__NetworkReader = NetworkReader
        NetworkWriter  = kwargs.pop("NetworkWriter", None)
        self.__NetworkWriter = NetworkWriter
        RtpHeaderHeard  = kwargs.pop("RtpHeaderHeard", None)
        self.__RtpHeaderHeard = RtpHeaderHeard
        StandAlone  = kwargs.pop("StandAlone", None)
        self.__StandAlone = StandAlone
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        multicastRelayHost  = kwargs.pop("multicastRelayHost", None)
        self.__multicastRelayHost = multicastRelayHost
        multicastRelayPort  = kwargs.pop("multicastRelayPort", 0)
        self.__multicastRelayPort = multicastRelayPort
        networkMode  = kwargs.pop("networkMode", "standAlone")
        if 'standAlone' == networkMode:
            pass
        elif 'networkReader' == networkMode:
            pass
        elif 'networkWriter' == networkMode:
            pass
        else:
            return None
        self.__networkMode = networkMode
        port  = kwargs.pop("port", 0)
        self.__port = port
        radioID  = kwargs.pop("radioID", 0)
        self.__radioID = radioID
        readInterval  = kwargs.pop("readInterval", 0.1)
        if readInterval == None or readInterval  <  0:
            return None
        self.__readInterval = readInterval
        rtpHeaderExpected  = kwargs.pop("rtpHeaderExpected", False)
        self.__rtpHeaderExpected = rtpHeaderExpected
        sampleRate  = kwargs.pop("sampleRate", 0)
        self.__sampleRate = sampleRate
        samples  = kwargs.pop("samples", 0)
        self.__samples = samples
        siteID  = kwargs.pop("siteID", 0)
        self.__siteID = siteID
        tdlType  = kwargs.pop("tdlType", 0)
        self.__tdlType = tdlType
        timestamp  = kwargs.pop("timestamp", None)
        if timestamp == None or timestamp  <  0:
            return None
        self.__timestamp = timestamp
        whichGeometry  = kwargs.pop("whichGeometry", 1)
        self.__whichGeometry = whichGeometry
        writeInterval  = kwargs.pop("writeInterval", 1.0)
        if writeInterval == None or writeInterval  <  0:
            return None
        self.__writeInterval = writeInterval
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def address(self):
        return self.__address
    @address.setter
    def address(self, value = "localhost"):
        self.__address = [value]
    def address(self, address = "localhost"):
        if self.__address == None:            self.__address =  []
        self.__address +=  [address]
        return self
    def removeAddress(self, address):
        self.__address = [x for x in self.__address if x not in address]
        return self.__address
    def getAddress(self, address = "localhost"):
        return self.__address
    def address_changed(self, address = "localhost"):
        return self.__address
    @property
    def applicationID(self):
        return self.__applicationID
    @applicationID.setter
    def applicationID(self, value = 0):
        self.__applicationID = [value]
    def setApplicationID(self, applicationID = 0):
        self.__applicationID = [applicationID]
        return self
    def addApplicationID(self, applicationID = 0):
        if self.__applicationID == None:            self.__applicationID =  []
        self.__applicationID +=  [applicationID]
        return self
    def removeApplicationID(self, applicationID):
        self.__applicationID = [x for x in self.__applicationID if x not in applicationID]
        return self.__applicationID
    def getApplicationID(self, applicationID = 0):
        return self.__applicationID
    def applicationID_changed(self, applicationID = 0):
        return self.__applicationID
    @property
    def data(self):
        return self.__data
    @data.setter
    def data(self, value = None):
        self.__data = [value]
    def setData(self, data = None):
        self.__data = [data]
        return self
    def addData(self, data = None):
        if self.__data == None:            self.__data =  []
        self.__data +=  [data]
        return self
    def removeData(self, data):
        self.__data = [x for x in self.__data if x not in data]
        return self.__data
    def getData(self, data = None):
        return self.__data
    def data_changed(self, data = None):
        return self.__data
    @property
    def dataLength(self):
        return self.__dataLength
    @dataLength.setter
    def dataLength(self, value = 0):
        self.__dataLength = [value]
    def setDataLength(self, dataLength = 0):
        self.__dataLength = [dataLength]
        return self
    def addDataLength(self, dataLength = 0):
        if self.__dataLength == None:            self.__dataLength =  []
        self.__dataLength +=  [dataLength]
        return self
    def removeDataLength(self, dataLength):
        self.__dataLength = [x for x in self.__dataLength if x not in dataLength]
        return self.__dataLength
    def getDataLength(self, dataLength = 0):
        return self.__dataLength
    def dataLength_changed(self, dataLength = 0):
        return self.__dataLength
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def encodingScheme(self):
        return self.__encodingScheme
    @encodingScheme.setter
    def encodingScheme(self, value = 0):
        self.__encodingScheme = [value]
    def setEncodingScheme(self, encodingScheme = 0):
        self.__encodingScheme = [encodingScheme]
        return self
    def addEncodingScheme(self, encodingScheme = 0):
        if self.__encodingScheme == None:            self.__encodingScheme =  []
        self.__encodingScheme +=  [encodingScheme]
        return self
    def removeEncodingScheme(self, encodingScheme):
        self.__encodingScheme = [x for x in self.__encodingScheme if x not in encodingScheme]
        return self.__encodingScheme
    def getEncodingScheme(self, encodingScheme = 0):
        return self.__encodingScheme
    def encodingScheme_changed(self, encodingScheme = 0):
        return self.__encodingScheme
    @property
    def entityID(self):
        return self.__entityID
    @entityID.setter
    def entityID(self, value = 0):
        self.__entityID = [value]
    def setEntityID(self, entityID = 0):
        self.__entityID = [entityID]
        return self
    def addEntityID(self, entityID = 0):
        if self.__entityID == None:            self.__entityID =  []
        self.__entityID +=  [entityID]
        return self
    def removeEntityID(self, entityID):
        self.__entityID = [x for x in self.__entityID if x not in entityID]
        return self.__entityID
    def getEntityID(self, entityID = 0):
        return self.__entityID
    def entityID_changed(self, entityID = 0):
        return self.__entityID
    @property
    def geoCoords(self):
        return self.__geoCoords
    @geoCoords.setter
    def geoCoords(self, value = [0, 0, 0]):
        self.__geoCoords = [value]
    def setGeoCoords(self, geoCoords = [0, 0, 0]):
        self.__geoCoords = [geoCoords]
        return self
    def addGeoCoords(self, geoCoords = [0, 0, 0]):
        if self.__geoCoords == None:            self.__geoCoords =  []
        self.__geoCoords +=  [geoCoords]
        return self
    def removeGeoCoords(self, geoCoords):
        self.__geoCoords = [x for x in self.__geoCoords if x not in geoCoords]
        return self.__geoCoords
    def getGeoCoords(self, geoCoords = [0, 0, 0]):
        return self.__geoCoords
    def geoCoords_changed(self, geoCoords = [0, 0, 0]):
        return self.__geoCoords
    def isActive(self, Active = None):
        return self.__Active
    def isNetworkReader(self, NetworkReader = None):
        return self.__NetworkReader
    def isNetworkWriter(self, NetworkWriter = None):
        return self.__NetworkWriter
    def isRtpHeaderHeard(self, RtpHeaderHeard = None):
        return self.__RtpHeaderHeard
    def isStandAlone(self, StandAlone = None):
        return self.__StandAlone
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def multicastRelayHost(self):
        return self.__multicastRelayHost
    @multicastRelayHost.setter
    def multicastRelayHost(self, value = None):
        self.__multicastRelayHost = [value]
    def setMulticastRelayHost(self, multicastRelayHost = None):
        self.__multicastRelayHost = [multicastRelayHost]
        return self
    def addMulticastRelayHost(self, multicastRelayHost = None):
        if self.__multicastRelayHost == None:            self.__multicastRelayHost =  []
        self.__multicastRelayHost +=  [multicastRelayHost]
        return self
    def removeMulticastRelayHost(self, multicastRelayHost):
        self.__multicastRelayHost = [x for x in self.__multicastRelayHost if x not in multicastRelayHost]
        return self.__multicastRelayHost
    def getMulticastRelayHost(self, multicastRelayHost = None):
        return self.__multicastRelayHost
    def multicastRelayHost_changed(self, multicastRelayHost = None):
        return self.__multicastRelayHost
    @property
    def multicastRelayPort(self):
        return self.__multicastRelayPort
    @multicastRelayPort.setter
    def multicastRelayPort(self, value = 0):
        self.__multicastRelayPort = [value]
    def setMulticastRelayPort(self, multicastRelayPort = 0):
        self.__multicastRelayPort = [multicastRelayPort]
        return self
    def addMulticastRelayPort(self, multicastRelayPort = 0):
        if self.__multicastRelayPort == None:            self.__multicastRelayPort =  []
        self.__multicastRelayPort +=  [multicastRelayPort]
        return self
    def removeMulticastRelayPort(self, multicastRelayPort):
        self.__multicastRelayPort = [x for x in self.__multicastRelayPort if x not in multicastRelayPort]
        return self.__multicastRelayPort
    def getMulticastRelayPort(self, multicastRelayPort = 0):
        return self.__multicastRelayPort
    def multicastRelayPort_changed(self, multicastRelayPort = 0):
        return self.__multicastRelayPort
    @property
    def networkMode(self):
        return self.__networkMode
    @networkMode.setter
    def networkMode(self, value = "standAlone"):
        if 'standAlone' == value:
            pass
        elif 'networkReader' == value:
            pass
        elif 'networkWriter' == value:
            pass
        else:
            return None
        self.__networkMode = [value]
    def setNetworkMode(self, networkMode = "standAlone"):
        if 'standAlone' == networkMode:
            pass
        elif 'networkReader' == networkMode:
            pass
        elif 'networkWriter' == networkMode:
            pass
        else:
            return None
        self.__networkMode = [networkMode]
        return self
    def addNetworkMode(self, networkMode = "standAlone"):
        if 'standAlone' == networkMode:
            pass
        elif 'networkReader' == networkMode:
            pass
        elif 'networkWriter' == networkMode:
            pass
        else:
            return None
        if self.__networkMode == None:            self.__networkMode =  []
        self.__networkMode +=  [networkMode]
        return self
    def removeNetworkMode(self, networkMode):
        self.__networkMode = [x for x in self.__networkMode if x not in networkMode]
        return self.__networkMode
    def getNetworkMode(self, networkMode = "standAlone"):
        return self.__networkMode
    def networkMode_changed(self, networkMode = "standAlone"):
        return self.__networkMode
    @property
    def port(self):
        return self.__port
    @port.setter
    def port(self, value = 0):
        self.__port = [value]
    def setPort(self, port = 0):
        self.__port = [port]
        return self
    def addPort(self, port = 0):
        if self.__port == None:            self.__port =  []
        self.__port +=  [port]
        return self
    def removePort(self, port):
        self.__port = [x for x in self.__port if x not in port]
        return self.__port
    def getPort(self, port = 0):
        return self.__port
    def port_changed(self, port = 0):
        return self.__port
    @property
    def radioID(self):
        return self.__radioID
    @radioID.setter
    def radioID(self, value = 0):
        self.__radioID = [value]
    def setRadioID(self, radioID = 0):
        self.__radioID = [radioID]
        return self
    def addRadioID(self, radioID = 0):
        if self.__radioID == None:            self.__radioID =  []
        self.__radioID +=  [radioID]
        return self
    def removeRadioID(self, radioID):
        self.__radioID = [x for x in self.__radioID if x not in radioID]
        return self.__radioID
    def getRadioID(self, radioID = 0):
        return self.__radioID
    def radioID_changed(self, radioID = 0):
        return self.__radioID
    @property
    def readInterval(self):
        return self.__readInterval
    @readInterval.setter
    def readInterval(self, value = 0.1):
        if value == None or value  <  0:
            return None
        self.__readInterval = [value]
    def setReadInterval(self, readInterval = 0.1):
        if readInterval == None or readInterval  <  0:
            return None
        self.__readInterval = [readInterval]
        return self
    def addReadInterval(self, readInterval = 0.1):
        if readInterval == None or readInterval  <  0:
            return None
        if self.__readInterval == None:            self.__readInterval =  []
        self.__readInterval +=  [readInterval]
        return self
    def removeReadInterval(self, readInterval):
        self.__readInterval = [x for x in self.__readInterval if x not in readInterval]
        return self.__readInterval
    def getReadInterval(self, readInterval = 0.1):
        return self.__readInterval
    def readInterval_changed(self, readInterval = 0.1):
        return self.__readInterval
    @property
    def sampleRate(self):
        return self.__sampleRate
    @sampleRate.setter
    def sampleRate(self, value = 0):
        self.__sampleRate = [value]
    def setSampleRate(self, sampleRate = 0):
        self.__sampleRate = [sampleRate]
        return self
    def addSampleRate(self, sampleRate = 0):
        if self.__sampleRate == None:            self.__sampleRate =  []
        self.__sampleRate +=  [sampleRate]
        return self
    def removeSampleRate(self, sampleRate):
        self.__sampleRate = [x for x in self.__sampleRate if x not in sampleRate]
        return self.__sampleRate
    def getSampleRate(self, sampleRate = 0):
        return self.__sampleRate
    def sampleRate_changed(self, sampleRate = 0):
        return self.__sampleRate
    @property
    def samples(self):
        return self.__samples
    @samples.setter
    def samples(self, value = 0):
        self.__samples = [value]
    def setSamples(self, samples = 0):
        self.__samples = [samples]
        return self
    def addSamples(self, samples = 0):
        if self.__samples == None:            self.__samples =  []
        self.__samples +=  [samples]
        return self
    def removeSamples(self, samples):
        self.__samples = [x for x in self.__samples if x not in samples]
        return self.__samples
    def getSamples(self, samples = 0):
        return self.__samples
    def samples_changed(self, samples = 0):
        return self.__samples
    @property
    def siteID(self):
        return self.__siteID
    @siteID.setter
    def siteID(self, value = 0):
        self.__siteID = [value]
    def setSiteID(self, siteID = 0):
        self.__siteID = [siteID]
        return self
    def addSiteID(self, siteID = 0):
        if self.__siteID == None:            self.__siteID =  []
        self.__siteID +=  [siteID]
        return self
    def removeSiteID(self, siteID):
        self.__siteID = [x for x in self.__siteID if x not in siteID]
        return self.__siteID
    def getSiteID(self, siteID = 0):
        return self.__siteID
    def siteID_changed(self, siteID = 0):
        return self.__siteID
    @property
    def tdlType(self):
        return self.__tdlType
    @tdlType.setter
    def tdlType(self, value = 0):
        self.__tdlType = [value]
    def setTdlType(self, tdlType = 0):
        self.__tdlType = [tdlType]
        return self
    def addTdlType(self, tdlType = 0):
        if self.__tdlType == None:            self.__tdlType =  []
        self.__tdlType +=  [tdlType]
        return self
    def removeTdlType(self, tdlType):
        self.__tdlType = [x for x in self.__tdlType if x not in tdlType]
        return self.__tdlType
    def getTdlType(self, tdlType = 0):
        return self.__tdlType
    def tdlType_changed(self, tdlType = 0):
        return self.__tdlType
    def removeTimestamp(self, timestamp):
        self.__timestamp = [x for x in self.__timestamp if x not in timestamp]
        return self.__timestamp
    def getTimestamp(self, timestamp = None):
        return self.__timestamp
    def timestamp_changed(self, timestamp = None):
        return self.__timestamp
    @property
    def whichGeometry(self):
        return self.__whichGeometry
    @whichGeometry.setter
    def whichGeometry(self, value = 1):
        self.__whichGeometry = [value]
    def setWhichGeometry(self, whichGeometry = 1):
        self.__whichGeometry = [whichGeometry]
        return self
    def addWhichGeometry(self, whichGeometry = 1):
        if self.__whichGeometry == None:            self.__whichGeometry =  []
        self.__whichGeometry +=  [whichGeometry]
        return self
    def removeWhichGeometry(self, whichGeometry):
        self.__whichGeometry = [x for x in self.__whichGeometry if x not in whichGeometry]
        return self.__whichGeometry
    def getWhichGeometry(self, whichGeometry = 1):
        return self.__whichGeometry
    def whichGeometry_changed(self, whichGeometry = 1):
        return self.__whichGeometry
    @property
    def writeInterval(self):
        return self.__writeInterval
    @writeInterval.setter
    def writeInterval(self, value = 1.0):
        if value == None or value  <  0:
            return None
        self.__writeInterval = [value]
    def setWriteInterval(self, writeInterval = 1.0):
        if writeInterval == None or writeInterval  <  0:
            return None
        self.__writeInterval = [writeInterval]
        return self
    def addWriteInterval(self, writeInterval = 1.0):
        if writeInterval == None or writeInterval  <  0:
            return None
        if self.__writeInterval == None:            self.__writeInterval =  []
        self.__writeInterval +=  [writeInterval]
        return self
    def removeWriteInterval(self, writeInterval):
        self.__writeInterval = [x for x in self.__writeInterval if x not in writeInterval]
        return self.__writeInterval
    def getWriteInterval(self, writeInterval = 1.0):
        return self.__writeInterval
    def writeInterval_changed(self, writeInterval = 1.0):
        return self.__writeInterval
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<SignalPdu'
        if self.__address is not None:
            if isinstance(self.__address, six.string_types):
                str += ' address="'+self.__address+'"'
            else:
                str += ' address="'+self.__address[0]+'"'
        if self.__applicationID is not None:
            if isinstance(self.__applicationID, six.string_types):
                str += ' applicationID="'+self.__applicationID+'"'
            else:
                str += ' applicationID="'+self.__applicationID[0]+'"'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__data is not None:
            if isinstance(self.__data, six.string_types):
                str += ' data="'+self.__data+'"'
            else:
                str += ' data="'+self.__data[0]+'"'
        if self.__dataLength is not None:
            if isinstance(self.__dataLength, six.string_types):
                str += ' dataLength="'+self.__dataLength+'"'
            else:
                str += ' dataLength="'+self.__dataLength[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__encodingScheme is not None:
            if isinstance(self.__encodingScheme, six.string_types):
                str += ' encodingScheme="'+self.__encodingScheme+'"'
            else:
                str += ' encodingScheme="'+self.__encodingScheme[0]+'"'
        if self.__entityID is not None:
            if isinstance(self.__entityID, six.string_types):
                str += ' entityID="'+self.__entityID+'"'
            else:
                str += ' entityID="'+self.__entityID[0]+'"'
        if self.__geoCoords is not None:
            if isinstance(self.__geoCoords, six.string_types):
                str += ' geoCoords="'+self.__geoCoords+'"'
            else:
                str += ' geoCoords="'+self.__geoCoords[0]+'"'
        if self.__geoSystem is not None:
            if isinstance(self.__geoSystem, six.string_types):
                str += ' geoSystem="'+self.__geoSystem+'"'
            else:
                str += ' geoSystem="'+self.__geoSystem[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__NetworkReader is not None:
            if isinstance(self.__NetworkReader, six.string_types):
                str += ' NetworkReader="'+self.__NetworkReader+'"'
            else:
                str += ' NetworkReader="'+self.__NetworkReader[0]+'"'
        if self.__NetworkWriter is not None:
            if isinstance(self.__NetworkWriter, six.string_types):
                str += ' NetworkWriter="'+self.__NetworkWriter+'"'
            else:
                str += ' NetworkWriter="'+self.__NetworkWriter[0]+'"'
        if self.__RtpHeaderHeard is not None:
            if isinstance(self.__RtpHeaderHeard, six.string_types):
                str += ' RtpHeaderHeard="'+self.__RtpHeaderHeard+'"'
            else:
                str += ' RtpHeaderHeard="'+self.__RtpHeaderHeard[0]+'"'
        if self.__StandAlone is not None:
            if isinstance(self.__StandAlone, six.string_types):
                str += ' StandAlone="'+self.__StandAlone+'"'
            else:
                str += ' StandAlone="'+self.__StandAlone[0]+'"'
        if self.__multicastRelayHost is not None:
            if isinstance(self.__multicastRelayHost, six.string_types):
                str += ' multicastRelayHost="'+self.__multicastRelayHost+'"'
            else:
                str += ' multicastRelayHost="'+self.__multicastRelayHost[0]+'"'
        if self.__multicastRelayPort is not None:
            if isinstance(self.__multicastRelayPort, six.string_types):
                str += ' multicastRelayPort="'+self.__multicastRelayPort+'"'
            else:
                str += ' multicastRelayPort="'+self.__multicastRelayPort[0]+'"'
        if self.__networkMode is not None:
            if isinstance(self.__networkMode, six.string_types):
                str += ' networkMode="'+self.__networkMode+'"'
            else:
                str += ' networkMode="'+self.__networkMode[0]+'"'
        if self.__port is not None:
            if isinstance(self.__port, six.string_types):
                str += ' port="'+self.__port+'"'
            else:
                str += ' port="'+self.__port[0]+'"'
        if self.__radioID is not None:
            if isinstance(self.__radioID, six.string_types):
                str += ' radioID="'+self.__radioID+'"'
            else:
                str += ' radioID="'+self.__radioID[0]+'"'
        if self.__readInterval is not None:
            if isinstance(self.__readInterval, six.string_types):
                str += ' readInterval="'+self.__readInterval+'"'
            else:
                str += ' readInterval="'+self.__readInterval[0]+'"'
        if self.__rtpHeaderExpected is not None:
            if isinstance(self.__rtpHeaderExpected, six.string_types):
                str += ' rtpHeaderExpected="'+self.__rtpHeaderExpected+'"'
            else:
                str += ' rtpHeaderExpected="'+self.__rtpHeaderExpected[0]+'"'
        if self.__sampleRate is not None:
            if isinstance(self.__sampleRate, six.string_types):
                str += ' sampleRate="'+self.__sampleRate+'"'
            else:
                str += ' sampleRate="'+self.__sampleRate[0]+'"'
        if self.__samples is not None:
            if isinstance(self.__samples, six.string_types):
                str += ' samples="'+self.__samples+'"'
            else:
                str += ' samples="'+self.__samples[0]+'"'
        if self.__siteID is not None:
            if isinstance(self.__siteID, six.string_types):
                str += ' siteID="'+self.__siteID+'"'
            else:
                str += ' siteID="'+self.__siteID[0]+'"'
        if self.__tdlType is not None:
            if isinstance(self.__tdlType, six.string_types):
                str += ' tdlType="'+self.__tdlType+'"'
            else:
                str += ' tdlType="'+self.__tdlType[0]+'"'
        if self.__timestamp is not None:
            if isinstance(self.__timestamp, six.string_types):
                str += ' timestamp="'+self.__timestamp+'"'
            else:
                str += ' timestamp="'+self.__timestamp[0]+'"'
        if self.__whichGeometry is not None:
            if isinstance(self.__whichGeometry, six.string_types):
                str += ' whichGeometry="'+self.__whichGeometry+'"'
            else:
                str += ' whichGeometry="'+self.__whichGeometry[0]+'"'
        if self.__writeInterval is not None:
            if isinstance(self.__writeInterval, six.string_types):
                str += ' writeInterval="'+self.__writeInterval+'"'
            else:
                str += ' writeInterval="'+self.__writeInterval[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</SignalPdu>'
        return str


class SilhouetteEnhancementVolumeStyle(X3DComposableVolumeRenderStyleNode):
    def __init__(self, **kwargs):
        super(SilhouetteEnhancementVolumeStyle, self).__init__(**kwargs)
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        silhouetteBoundaryOpacity  = kwargs.pop("silhouetteBoundaryOpacity", 0)
        if silhouetteBoundaryOpacity == None or silhouetteBoundaryOpacity  <  0:
            return None
        if silhouetteBoundaryOpacity == None or silhouetteBoundaryOpacity  >  1:
            return None
        self.__silhouetteBoundaryOpacity = silhouetteBoundaryOpacity
        silhouetteRetainedOpacity  = kwargs.pop("silhouetteRetainedOpacity", 1)
        if silhouetteRetainedOpacity == None or silhouetteRetainedOpacity  <  0:
            return None
        if silhouetteRetainedOpacity == None or silhouetteRetainedOpacity  >  1:
            return None
        self.__silhouetteRetainedOpacity = silhouetteRetainedOpacity
        silhouetteSharpness  = kwargs.pop("silhouetteSharpness", 0.5)
        if silhouetteSharpness == None or silhouetteSharpness  <  0:
            return None
        self.__silhouetteSharpness = silhouetteSharpness
        surfaceNormals  = kwargs.pop("surfaceNormals", None)
        self.__surfaceNormals = surfaceNormals
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def silhouetteBoundaryOpacity(self):
        return self.__silhouetteBoundaryOpacity
    @silhouetteBoundaryOpacity.setter
    def silhouetteBoundaryOpacity(self, value = 0):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__silhouetteBoundaryOpacity = [value]
    def setSilhouetteBoundaryOpacity(self, silhouetteBoundaryOpacity = 0):
        if silhouetteBoundaryOpacity == None or silhouetteBoundaryOpacity  <  0:
            return None
        if silhouetteBoundaryOpacity == None or silhouetteBoundaryOpacity  >  1:
            return None
        self.__silhouetteBoundaryOpacity = [silhouetteBoundaryOpacity]
        return self
    def addSilhouetteBoundaryOpacity(self, silhouetteBoundaryOpacity = 0):
        if silhouetteBoundaryOpacity == None or silhouetteBoundaryOpacity  <  0:
            return None
        if silhouetteBoundaryOpacity == None or silhouetteBoundaryOpacity  >  1:
            return None
        if self.__silhouetteBoundaryOpacity == None:            self.__silhouetteBoundaryOpacity =  []
        self.__silhouetteBoundaryOpacity +=  [silhouetteBoundaryOpacity]
        return self
    def removeSilhouetteBoundaryOpacity(self, silhouetteBoundaryOpacity):
        self.__silhouetteBoundaryOpacity = [x for x in self.__silhouetteBoundaryOpacity if x not in silhouetteBoundaryOpacity]
        return self.__silhouetteBoundaryOpacity
    def getSilhouetteBoundaryOpacity(self, silhouetteBoundaryOpacity = 0):
        return self.__silhouetteBoundaryOpacity
    def silhouetteBoundaryOpacity_changed(self, silhouetteBoundaryOpacity = 0):
        return self.__silhouetteBoundaryOpacity
    @property
    def silhouetteRetainedOpacity(self):
        return self.__silhouetteRetainedOpacity
    @silhouetteRetainedOpacity.setter
    def silhouetteRetainedOpacity(self, value = 1):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__silhouetteRetainedOpacity = [value]
    def setSilhouetteRetainedOpacity(self, silhouetteRetainedOpacity = 1):
        if silhouetteRetainedOpacity == None or silhouetteRetainedOpacity  <  0:
            return None
        if silhouetteRetainedOpacity == None or silhouetteRetainedOpacity  >  1:
            return None
        self.__silhouetteRetainedOpacity = [silhouetteRetainedOpacity]
        return self
    def addSilhouetteRetainedOpacity(self, silhouetteRetainedOpacity = 1):
        if silhouetteRetainedOpacity == None or silhouetteRetainedOpacity  <  0:
            return None
        if silhouetteRetainedOpacity == None or silhouetteRetainedOpacity  >  1:
            return None
        if self.__silhouetteRetainedOpacity == None:            self.__silhouetteRetainedOpacity =  []
        self.__silhouetteRetainedOpacity +=  [silhouetteRetainedOpacity]
        return self
    def removeSilhouetteRetainedOpacity(self, silhouetteRetainedOpacity):
        self.__silhouetteRetainedOpacity = [x for x in self.__silhouetteRetainedOpacity if x not in silhouetteRetainedOpacity]
        return self.__silhouetteRetainedOpacity
    def getSilhouetteRetainedOpacity(self, silhouetteRetainedOpacity = 1):
        return self.__silhouetteRetainedOpacity
    def silhouetteRetainedOpacity_changed(self, silhouetteRetainedOpacity = 1):
        return self.__silhouetteRetainedOpacity
    @property
    def silhouetteSharpness(self):
        return self.__silhouetteSharpness
    @silhouetteSharpness.setter
    def silhouetteSharpness(self, value = 0.5):
        if value == None or value  <  0:
            return None
        self.__silhouetteSharpness = [value]
    def setSilhouetteSharpness(self, silhouetteSharpness = 0.5):
        if silhouetteSharpness == None or silhouetteSharpness  <  0:
            return None
        self.__silhouetteSharpness = [silhouetteSharpness]
        return self
    def addSilhouetteSharpness(self, silhouetteSharpness = 0.5):
        if silhouetteSharpness == None or silhouetteSharpness  <  0:
            return None
        if self.__silhouetteSharpness == None:            self.__silhouetteSharpness =  []
        self.__silhouetteSharpness +=  [silhouetteSharpness]
        return self
    def removeSilhouetteSharpness(self, silhouetteSharpness):
        self.__silhouetteSharpness = [x for x in self.__silhouetteSharpness if x not in silhouetteSharpness]
        return self.__silhouetteSharpness
    def getSilhouetteSharpness(self, silhouetteSharpness = 0.5):
        return self.__silhouetteSharpness
    def silhouetteSharpness_changed(self, silhouetteSharpness = 0.5):
        return self.__silhouetteSharpness
    @property
    def surfaceNormals(self):
        return self.__surfaceNormals
    @surfaceNormals.setter
    def surfaceNormals(self, value = None):
        self.__surfaceNormals = [value]
    def setSurfaceNormals(self, surfaceNormals = None):
        self.__surfaceNormals = [surfaceNormals]
        return self
    def addSurfaceNormals(self, surfaceNormals = None):
        if self.__surfaceNormals == None:            self.__surfaceNormals =  []
        self.__surfaceNormals +=  [surfaceNormals]
        return self
    def removeSurfaceNormals(self, surfaceNormals):
        self.__surfaceNormals = [x for x in self.__surfaceNormals if x not in surfaceNormals]
        return self.__surfaceNormals
    def getSurfaceNormals(self, surfaceNormals = None):
        return self.__surfaceNormals
    def surfaceNormals_changed(self, surfaceNormals = None):
        return self.__surfaceNormals
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<SilhouetteEnhancementVolumeStyle'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__silhouetteBoundaryOpacity is not None:
            if isinstance(self.__silhouetteBoundaryOpacity, six.string_types):
                str += ' silhouetteBoundaryOpacity="'+self.__silhouetteBoundaryOpacity+'"'
            else:
                str += ' silhouetteBoundaryOpacity="'+self.__silhouetteBoundaryOpacity[0]+'"'
        if self.__silhouetteRetainedOpacity is not None:
            if isinstance(self.__silhouetteRetainedOpacity, six.string_types):
                str += ' silhouetteRetainedOpacity="'+self.__silhouetteRetainedOpacity+'"'
            else:
                str += ' silhouetteRetainedOpacity="'+self.__silhouetteRetainedOpacity[0]+'"'
        if self.__silhouetteSharpness is not None:
            if isinstance(self.__silhouetteSharpness, six.string_types):
                str += ' silhouetteSharpness="'+self.__silhouetteSharpness+'"'
            else:
                str += ' silhouetteSharpness="'+self.__silhouetteSharpness[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<surfaceNormals'
        if self.__surfaceNormals is not None:
           for s in self.__surfaceNormals:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__surfaceNormals is not None:
           for s in self.__surfaceNormals:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</surfaceNormals>'
        str += '</SilhouetteEnhancementVolumeStyle>'
        return str


class SingleAxisHingeJoint(X3DRigidJointNode):
    def __init__(self, **kwargs):
        super(SingleAxisHingeJoint, self).__init__(**kwargs)
        anchorPoint  = kwargs.pop("anchorPoint", [0, 0, 0])
        self.__anchorPoint = anchorPoint
        angle  = kwargs.pop("angle", None)
        self.__angle = angle
        angleRate  = kwargs.pop("angleRate", None)
        self.__angleRate = angleRate
        axis  = kwargs.pop("axis", [0, 0, 0])
        self.__axis = axis
        body1  = kwargs.pop("body1", None)
        self.__body1 = body1
        body1AnchorPoint  = kwargs.pop("body1AnchorPoint", None)
        self.__body1AnchorPoint = body1AnchorPoint
        body2  = kwargs.pop("body2", None)
        self.__body2 = body2
        body2AnchorPoint  = kwargs.pop("body2AnchorPoint", None)
        self.__body2AnchorPoint = body2AnchorPoint
        forceOutput  = kwargs.pop("forceOutput", ["NONE"])
        self.__forceOutput = forceOutput
        maxAngle  = kwargs.pop("maxAngle", 3.141592653)
        self.__maxAngle = maxAngle
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        minAngle  = kwargs.pop("minAngle", -3.141592653)
        self.__minAngle = minAngle
        stopBounce  = kwargs.pop("stopBounce", 0)
        self.__stopBounce = stopBounce
        stopErrorCorrection  = kwargs.pop("stopErrorCorrection", 0.8)
        self.__stopErrorCorrection = stopErrorCorrection
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def anchorPoint(self):
        return self.__anchorPoint
    @anchorPoint.setter
    def anchorPoint(self, value = [0, 0, 0]):
        self.__anchorPoint = [value]
    def setAnchorPoint(self, anchorPoint = [0, 0, 0]):
        self.__anchorPoint = [anchorPoint]
        return self
    def addAnchorPoint(self, anchorPoint = [0, 0, 0]):
        if self.__anchorPoint == None:            self.__anchorPoint =  []
        self.__anchorPoint +=  [anchorPoint]
        return self
    def removeAnchorPoint(self, anchorPoint):
        self.__anchorPoint = [x for x in self.__anchorPoint if x not in anchorPoint]
        return self.__anchorPoint
    def getAnchorPoint(self, anchorPoint = [0, 0, 0]):
        return self.__anchorPoint
    def anchorPoint_changed(self, anchorPoint = [0, 0, 0]):
        return self.__anchorPoint
    def removeAngle(self, angle):
        self.__angle = [x for x in self.__angle if x not in angle]
        return self.__angle
    def getAngle(self, angle = None):
        return self.__angle
    def angle_changed(self, angle = None):
        return self.__angle
    def removeAngleRate(self, angleRate):
        self.__angleRate = [x for x in self.__angleRate if x not in angleRate]
        return self.__angleRate
    def getAngleRate(self, angleRate = None):
        return self.__angleRate
    def angleRate_changed(self, angleRate = None):
        return self.__angleRate
    @property
    def axis(self):
        return self.__axis
    @axis.setter
    def axis(self, value = [0, 0, 0]):
        self.__axis = [value]
    def setAxis(self, axis = [0, 0, 0]):
        self.__axis = [axis]
        return self
    def addAxis(self, axis = [0, 0, 0]):
        if self.__axis == None:            self.__axis =  []
        self.__axis +=  [axis]
        return self
    def removeAxis(self, axis):
        self.__axis = [x for x in self.__axis if x not in axis]
        return self.__axis
    def getAxis(self, axis = [0, 0, 0]):
        return self.__axis
    def axis_changed(self, axis = [0, 0, 0]):
        return self.__axis
    @property
    def body1(self):
        return self.__body1
    @body1.setter
    def body1(self, value = None):
        self.__body1 = [value]
    def setBody1(self, body1 = None):
        self.__body1 = [body1]
        return self
    def addBody1(self, body1 = None):
        if self.__body1 == None:            self.__body1 =  []
        self.__body1 +=  [body1]
        return self
    def removeBody1(self, body1):
        self.__body1 = [x for x in self.__body1 if x not in body1]
        return self.__body1
    def getBody1(self, body1 = None):
        return self.__body1
    def body1_changed(self, body1 = None):
        return self.__body1
    def removeBody1AnchorPoint(self, body1AnchorPoint):
        self.__body1AnchorPoint = [x for x in self.__body1AnchorPoint if x not in body1AnchorPoint]
        return self.__body1AnchorPoint
    def getBody1AnchorPoint(self, body1AnchorPoint = None):
        return self.__body1AnchorPoint
    def body1AnchorPoint_changed(self, body1AnchorPoint = None):
        return self.__body1AnchorPoint
    @property
    def body2(self):
        return self.__body2
    @body2.setter
    def body2(self, value = None):
        self.__body2 = [value]
    def setBody2(self, body2 = None):
        self.__body2 = [body2]
        return self
    def addBody2(self, body2 = None):
        if self.__body2 == None:            self.__body2 =  []
        self.__body2 +=  [body2]
        return self
    def removeBody2(self, body2):
        self.__body2 = [x for x in self.__body2 if x not in body2]
        return self.__body2
    def getBody2(self, body2 = None):
        return self.__body2
    def body2_changed(self, body2 = None):
        return self.__body2
    def removeBody2AnchorPoint(self, body2AnchorPoint):
        self.__body2AnchorPoint = [x for x in self.__body2AnchorPoint if x not in body2AnchorPoint]
        return self.__body2AnchorPoint
    def getBody2AnchorPoint(self, body2AnchorPoint = None):
        return self.__body2AnchorPoint
    def body2AnchorPoint_changed(self, body2AnchorPoint = None):
        return self.__body2AnchorPoint
    @property
    def forceOutput(self):
        return self.__forceOutput
    @forceOutput.setter
    def forceOutput(self, value = ["NONE"]):
        self.__forceOutput = [value]
    def setForceOutput(self, forceOutput = ["NONE"]):
        self.__forceOutput = [forceOutput]
        return self
    def addForceOutput(self, forceOutput = ["NONE"]):
        if self.__forceOutput == None:            self.__forceOutput =  []
        self.__forceOutput +=  [forceOutput]
        return self
    def removeForceOutput(self, forceOutput):
        self.__forceOutput = [x for x in self.__forceOutput if x not in forceOutput]
        return self.__forceOutput
    def getForceOutput(self, forceOutput = ["NONE"]):
        return self.__forceOutput
    def forceOutput_changed(self, forceOutput = ["NONE"]):
        return self.__forceOutput
    @property
    def maxAngle(self):
        return self.__maxAngle
    @maxAngle.setter
    def maxAngle(self, value = 3.141592653):
        self.__maxAngle = [value]
    def setMaxAngle(self, maxAngle = 3.141592653):
        self.__maxAngle = [maxAngle]
        return self
    def addMaxAngle(self, maxAngle = 3.141592653):
        if self.__maxAngle == None:            self.__maxAngle =  []
        self.__maxAngle +=  [maxAngle]
        return self
    def removeMaxAngle(self, maxAngle):
        self.__maxAngle = [x for x in self.__maxAngle if x not in maxAngle]
        return self.__maxAngle
    def getMaxAngle(self, maxAngle = 3.141592653):
        return self.__maxAngle
    def maxAngle_changed(self, maxAngle = 3.141592653):
        return self.__maxAngle
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def minAngle(self):
        return self.__minAngle
    @minAngle.setter
    def minAngle(self, value = -3.141592653):
        self.__minAngle = [value]
    def setMinAngle(self, minAngle = -3.141592653):
        self.__minAngle = [minAngle]
        return self
    def addMinAngle(self, minAngle = -3.141592653):
        if self.__minAngle == None:            self.__minAngle =  []
        self.__minAngle +=  [minAngle]
        return self
    def removeMinAngle(self, minAngle):
        self.__minAngle = [x for x in self.__minAngle if x not in minAngle]
        return self.__minAngle
    def getMinAngle(self, minAngle = -3.141592653):
        return self.__minAngle
    def minAngle_changed(self, minAngle = -3.141592653):
        return self.__minAngle
    @property
    def stopBounce(self):
        return self.__stopBounce
    @stopBounce.setter
    def stopBounce(self, value = 0):
        self.__stopBounce = [value]
    def setStopBounce(self, stopBounce = 0):
        self.__stopBounce = [stopBounce]
        return self
    def addStopBounce(self, stopBounce = 0):
        if self.__stopBounce == None:            self.__stopBounce =  []
        self.__stopBounce +=  [stopBounce]
        return self
    def removeStopBounce(self, stopBounce):
        self.__stopBounce = [x for x in self.__stopBounce if x not in stopBounce]
        return self.__stopBounce
    def getStopBounce(self, stopBounce = 0):
        return self.__stopBounce
    def stopBounce_changed(self, stopBounce = 0):
        return self.__stopBounce
    @property
    def stopErrorCorrection(self):
        return self.__stopErrorCorrection
    @stopErrorCorrection.setter
    def stopErrorCorrection(self, value = 0.8):
        self.__stopErrorCorrection = [value]
    def setStopErrorCorrection(self, stopErrorCorrection = 0.8):
        self.__stopErrorCorrection = [stopErrorCorrection]
        return self
    def addStopErrorCorrection(self, stopErrorCorrection = 0.8):
        if self.__stopErrorCorrection == None:            self.__stopErrorCorrection =  []
        self.__stopErrorCorrection +=  [stopErrorCorrection]
        return self
    def removeStopErrorCorrection(self, stopErrorCorrection):
        self.__stopErrorCorrection = [x for x in self.__stopErrorCorrection if x not in stopErrorCorrection]
        return self.__stopErrorCorrection
    def getStopErrorCorrection(self, stopErrorCorrection = 0.8):
        return self.__stopErrorCorrection
    def stopErrorCorrection_changed(self, stopErrorCorrection = 0.8):
        return self.__stopErrorCorrection
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<SingleAxisHingeJoint'
        if self.__anchorPoint is not None:
            if isinstance(self.__anchorPoint, six.string_types):
                str += ' anchorPoint="'+self.__anchorPoint+'"'
            else:
                str += ' anchorPoint="'+self.__anchorPoint[0]+'"'
        if self.__angle is not None:
            if isinstance(self.__angle, six.string_types):
                str += ' angle="'+self.__angle+'"'
            else:
                str += ' angle="'+self.__angle[0]+'"'
        if self.__angleRate is not None:
            if isinstance(self.__angleRate, six.string_types):
                str += ' angleRate="'+self.__angleRate+'"'
            else:
                str += ' angleRate="'+self.__angleRate[0]+'"'
        if self.__axis is not None:
            if isinstance(self.__axis, six.string_types):
                str += ' axis="'+self.__axis+'"'
            else:
                str += ' axis="'+self.__axis[0]+'"'
        if self.__body1AnchorPoint is not None:
            if isinstance(self.__body1AnchorPoint, six.string_types):
                str += ' body1AnchorPoint="'+self.__body1AnchorPoint+'"'
            else:
                str += ' body1AnchorPoint="'+self.__body1AnchorPoint[0]+'"'
        if self.__body2AnchorPoint is not None:
            if isinstance(self.__body2AnchorPoint, six.string_types):
                str += ' body2AnchorPoint="'+self.__body2AnchorPoint+'"'
            else:
                str += ' body2AnchorPoint="'+self.__body2AnchorPoint[0]+'"'
        if self.__forceOutput is not None:
            if isinstance(self.__forceOutput, six.string_types):
                str += ' forceOutput="'+self.__forceOutput+'"'
            else:
                str += ' forceOutput="'+self.__forceOutput[0]+'"'
        if self.__maxAngle is not None:
            if isinstance(self.__maxAngle, six.string_types):
                str += ' maxAngle="'+self.__maxAngle+'"'
            else:
                str += ' maxAngle="'+self.__maxAngle[0]+'"'
        if self.__minAngle is not None:
            if isinstance(self.__minAngle, six.string_types):
                str += ' minAngle="'+self.__minAngle+'"'
            else:
                str += ' minAngle="'+self.__minAngle[0]+'"'
        if self.__stopBounce is not None:
            if isinstance(self.__stopBounce, six.string_types):
                str += ' stopBounce="'+self.__stopBounce+'"'
            else:
                str += ' stopBounce="'+self.__stopBounce[0]+'"'
        if self.__stopErrorCorrection is not None:
            if isinstance(self.__stopErrorCorrection, six.string_types):
                str += ' stopErrorCorrection="'+self.__stopErrorCorrection+'"'
            else:
                str += ' stopErrorCorrection="'+self.__stopErrorCorrection[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<body1'
        if self.__body1 is not None:
           for s in self.__body1:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__body1 is not None:
           for s in self.__body1:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</body1>'
        str += '<body2'
        if self.__body2 is not None:
           for s in self.__body2:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__body2 is not None:
           for s in self.__body2:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</body2>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</SingleAxisHingeJoint>'
        return str


class SliderJoint(X3DRigidJointNode):
    def __init__(self, **kwargs):
        super(SliderJoint, self).__init__(**kwargs)
        axis  = kwargs.pop("axis", [0, 1, 0])
        self.__axis = axis
        body1  = kwargs.pop("body1", None)
        self.__body1 = body1
        body2  = kwargs.pop("body2", None)
        self.__body2 = body2
        forceOutput  = kwargs.pop("forceOutput", ["NONE"])
        self.__forceOutput = forceOutput
        maxSeparation  = kwargs.pop("maxSeparation", 1)
        self.__maxSeparation = maxSeparation
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        minSeparation  = kwargs.pop("minSeparation", 0)
        self.__minSeparation = minSeparation
        separation  = kwargs.pop("separation", None)
        self.__separation = separation
        separationRate  = kwargs.pop("separationRate", None)
        self.__separationRate = separationRate
        sliderForce  = kwargs.pop("sliderForce", 0)
        self.__sliderForce = sliderForce
        stopBounce  = kwargs.pop("stopBounce", 0)
        self.__stopBounce = stopBounce
        stopErrorCorrection  = kwargs.pop("stopErrorCorrection", 1)
        self.__stopErrorCorrection = stopErrorCorrection
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def axis(self):
        return self.__axis
    @axis.setter
    def axis(self, value = [0, 1, 0]):
        self.__axis = [value]
    def setAxis(self, axis = [0, 1, 0]):
        self.__axis = [axis]
        return self
    def addAxis(self, axis = [0, 1, 0]):
        if self.__axis == None:            self.__axis =  []
        self.__axis +=  [axis]
        return self
    def removeAxis(self, axis):
        self.__axis = [x for x in self.__axis if x not in axis]
        return self.__axis
    def getAxis(self, axis = [0, 1, 0]):
        return self.__axis
    def axis_changed(self, axis = [0, 1, 0]):
        return self.__axis
    @property
    def body1(self):
        return self.__body1
    @body1.setter
    def body1(self, value = None):
        self.__body1 = [value]
    def setBody1(self, body1 = None):
        self.__body1 = [body1]
        return self
    def addBody1(self, body1 = None):
        if self.__body1 == None:            self.__body1 =  []
        self.__body1 +=  [body1]
        return self
    def removeBody1(self, body1):
        self.__body1 = [x for x in self.__body1 if x not in body1]
        return self.__body1
    def getBody1(self, body1 = None):
        return self.__body1
    def body1_changed(self, body1 = None):
        return self.__body1
    @property
    def body2(self):
        return self.__body2
    @body2.setter
    def body2(self, value = None):
        self.__body2 = [value]
    def setBody2(self, body2 = None):
        self.__body2 = [body2]
        return self
    def addBody2(self, body2 = None):
        if self.__body2 == None:            self.__body2 =  []
        self.__body2 +=  [body2]
        return self
    def removeBody2(self, body2):
        self.__body2 = [x for x in self.__body2 if x not in body2]
        return self.__body2
    def getBody2(self, body2 = None):
        return self.__body2
    def body2_changed(self, body2 = None):
        return self.__body2
    @property
    def forceOutput(self):
        return self.__forceOutput
    @forceOutput.setter
    def forceOutput(self, value = ["NONE"]):
        self.__forceOutput = [value]
    def setForceOutput(self, forceOutput = ["NONE"]):
        self.__forceOutput = [forceOutput]
        return self
    def addForceOutput(self, forceOutput = ["NONE"]):
        if self.__forceOutput == None:            self.__forceOutput =  []
        self.__forceOutput +=  [forceOutput]
        return self
    def removeForceOutput(self, forceOutput):
        self.__forceOutput = [x for x in self.__forceOutput if x not in forceOutput]
        return self.__forceOutput
    def getForceOutput(self, forceOutput = ["NONE"]):
        return self.__forceOutput
    def forceOutput_changed(self, forceOutput = ["NONE"]):
        return self.__forceOutput
    @property
    def maxSeparation(self):
        return self.__maxSeparation
    @maxSeparation.setter
    def maxSeparation(self, value = 1):
        self.__maxSeparation = [value]
    def setMaxSeparation(self, maxSeparation = 1):
        self.__maxSeparation = [maxSeparation]
        return self
    def addMaxSeparation(self, maxSeparation = 1):
        if self.__maxSeparation == None:            self.__maxSeparation =  []
        self.__maxSeparation +=  [maxSeparation]
        return self
    def removeMaxSeparation(self, maxSeparation):
        self.__maxSeparation = [x for x in self.__maxSeparation if x not in maxSeparation]
        return self.__maxSeparation
    def getMaxSeparation(self, maxSeparation = 1):
        return self.__maxSeparation
    def maxSeparation_changed(self, maxSeparation = 1):
        return self.__maxSeparation
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def minSeparation(self):
        return self.__minSeparation
    @minSeparation.setter
    def minSeparation(self, value = 0):
        self.__minSeparation = [value]
    def setMinSeparation(self, minSeparation = 0):
        self.__minSeparation = [minSeparation]
        return self
    def addMinSeparation(self, minSeparation = 0):
        if self.__minSeparation == None:            self.__minSeparation =  []
        self.__minSeparation +=  [minSeparation]
        return self
    def removeMinSeparation(self, minSeparation):
        self.__minSeparation = [x for x in self.__minSeparation if x not in minSeparation]
        return self.__minSeparation
    def getMinSeparation(self, minSeparation = 0):
        return self.__minSeparation
    def minSeparation_changed(self, minSeparation = 0):
        return self.__minSeparation
    def removeSeparation(self, separation):
        self.__separation = [x for x in self.__separation if x not in separation]
        return self.__separation
    def getSeparation(self, separation = None):
        return self.__separation
    def separation_changed(self, separation = None):
        return self.__separation
    def removeSeparationRate(self, separationRate):
        self.__separationRate = [x for x in self.__separationRate if x not in separationRate]
        return self.__separationRate
    def getSeparationRate(self, separationRate = None):
        return self.__separationRate
    def separationRate_changed(self, separationRate = None):
        return self.__separationRate
    @property
    def sliderForce(self):
        return self.__sliderForce
    @sliderForce.setter
    def sliderForce(self, value = 0):
        self.__sliderForce = [value]
    def setSliderForce(self, sliderForce = 0):
        self.__sliderForce = [sliderForce]
        return self
    def addSliderForce(self, sliderForce = 0):
        if self.__sliderForce == None:            self.__sliderForce =  []
        self.__sliderForce +=  [sliderForce]
        return self
    def removeSliderForce(self, sliderForce):
        self.__sliderForce = [x for x in self.__sliderForce if x not in sliderForce]
        return self.__sliderForce
    def getSliderForce(self, sliderForce = 0):
        return self.__sliderForce
    def sliderForce_changed(self, sliderForce = 0):
        return self.__sliderForce
    @property
    def stopBounce(self):
        return self.__stopBounce
    @stopBounce.setter
    def stopBounce(self, value = 0):
        self.__stopBounce = [value]
    def setStopBounce(self, stopBounce = 0):
        self.__stopBounce = [stopBounce]
        return self
    def addStopBounce(self, stopBounce = 0):
        if self.__stopBounce == None:            self.__stopBounce =  []
        self.__stopBounce +=  [stopBounce]
        return self
    def removeStopBounce(self, stopBounce):
        self.__stopBounce = [x for x in self.__stopBounce if x not in stopBounce]
        return self.__stopBounce
    def getStopBounce(self, stopBounce = 0):
        return self.__stopBounce
    def stopBounce_changed(self, stopBounce = 0):
        return self.__stopBounce
    @property
    def stopErrorCorrection(self):
        return self.__stopErrorCorrection
    @stopErrorCorrection.setter
    def stopErrorCorrection(self, value = 1):
        self.__stopErrorCorrection = [value]
    def setStopErrorCorrection(self, stopErrorCorrection = 1):
        self.__stopErrorCorrection = [stopErrorCorrection]
        return self
    def addStopErrorCorrection(self, stopErrorCorrection = 1):
        if self.__stopErrorCorrection == None:            self.__stopErrorCorrection =  []
        self.__stopErrorCorrection +=  [stopErrorCorrection]
        return self
    def removeStopErrorCorrection(self, stopErrorCorrection):
        self.__stopErrorCorrection = [x for x in self.__stopErrorCorrection if x not in stopErrorCorrection]
        return self.__stopErrorCorrection
    def getStopErrorCorrection(self, stopErrorCorrection = 1):
        return self.__stopErrorCorrection
    def stopErrorCorrection_changed(self, stopErrorCorrection = 1):
        return self.__stopErrorCorrection
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<SliderJoint'
        if self.__axis is not None:
            if isinstance(self.__axis, six.string_types):
                str += ' axis="'+self.__axis+'"'
            else:
                str += ' axis="'+self.__axis[0]+'"'
        if self.__forceOutput is not None:
            if isinstance(self.__forceOutput, six.string_types):
                str += ' forceOutput="'+self.__forceOutput+'"'
            else:
                str += ' forceOutput="'+self.__forceOutput[0]+'"'
        if self.__maxSeparation is not None:
            if isinstance(self.__maxSeparation, six.string_types):
                str += ' maxSeparation="'+self.__maxSeparation+'"'
            else:
                str += ' maxSeparation="'+self.__maxSeparation[0]+'"'
        if self.__minSeparation is not None:
            if isinstance(self.__minSeparation, six.string_types):
                str += ' minSeparation="'+self.__minSeparation+'"'
            else:
                str += ' minSeparation="'+self.__minSeparation[0]+'"'
        if self.__separation is not None:
            if isinstance(self.__separation, six.string_types):
                str += ' separation="'+self.__separation+'"'
            else:
                str += ' separation="'+self.__separation[0]+'"'
        if self.__separationRate is not None:
            if isinstance(self.__separationRate, six.string_types):
                str += ' separationRate="'+self.__separationRate+'"'
            else:
                str += ' separationRate="'+self.__separationRate[0]+'"'
        if self.__sliderForce is not None:
            if isinstance(self.__sliderForce, six.string_types):
                str += ' sliderForce="'+self.__sliderForce+'"'
            else:
                str += ' sliderForce="'+self.__sliderForce[0]+'"'
        if self.__stopBounce is not None:
            if isinstance(self.__stopBounce, six.string_types):
                str += ' stopBounce="'+self.__stopBounce+'"'
            else:
                str += ' stopBounce="'+self.__stopBounce[0]+'"'
        if self.__stopErrorCorrection is not None:
            if isinstance(self.__stopErrorCorrection, six.string_types):
                str += ' stopErrorCorrection="'+self.__stopErrorCorrection+'"'
            else:
                str += ' stopErrorCorrection="'+self.__stopErrorCorrection[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<body1'
        if self.__body1 is not None:
           for s in self.__body1:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__body1 is not None:
           for s in self.__body1:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</body1>'
        str += '<body2'
        if self.__body2 is not None:
           for s in self.__body2:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__body2 is not None:
           for s in self.__body2:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</body2>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</SliderJoint>'
        return str


class Sound(X3DSoundNode):
    def __init__(self, **kwargs):
        super(Sound, self).__init__(**kwargs)
        direction  = kwargs.pop("direction", [0, 0, 1])
        self.__direction = direction
        intensity  = kwargs.pop("intensity", 1)
        if intensity == None or intensity  <  0:
            return None
        if intensity == None or intensity  >  1:
            return None
        self.__intensity = intensity
        location  = kwargs.pop("location", [0, 0, 0])
        self.__location = location
        maxBack  = kwargs.pop("maxBack", 10)
        if maxBack == None or maxBack  <  0:
            return None
        self.__maxBack = maxBack
        maxFront  = kwargs.pop("maxFront", 10)
        if maxFront == None or maxFront  <  0:
            return None
        self.__maxFront = maxFront
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        minBack  = kwargs.pop("minBack", 1)
        if minBack == None or minBack  <  0:
            return None
        self.__minBack = minBack
        minFront  = kwargs.pop("minFront", 1)
        if minFront == None or minFront  <  0:
            return None
        self.__minFront = minFront
        priority  = kwargs.pop("priority", 0)
        if priority == None or priority  <  0:
            return None
        if priority == None or priority  >  1:
            return None
        self.__priority = priority
        source  = kwargs.pop("source", None)
        self.__source = source
        spatialize  = kwargs.pop("spatialize", True)
        self.__spatialize = spatialize
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def direction(self):
        return self.__direction
    @direction.setter
    def direction(self, value = [0, 0, 1]):
        self.__direction = [value]
    def setDirection(self, direction = [0, 0, 1]):
        self.__direction = [direction]
        return self
    def addDirection(self, direction = [0, 0, 1]):
        if self.__direction == None:            self.__direction =  []
        self.__direction +=  [direction]
        return self
    def removeDirection(self, direction):
        self.__direction = [x for x in self.__direction if x not in direction]
        return self.__direction
    def getDirection(self, direction = [0, 0, 1]):
        return self.__direction
    def direction_changed(self, direction = [0, 0, 1]):
        return self.__direction
    @property
    def intensity(self):
        return self.__intensity
    @intensity.setter
    def intensity(self, value = 1):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__intensity = [value]
    def setIntensity(self, intensity = 1):
        if intensity == None or intensity  <  0:
            return None
        if intensity == None or intensity  >  1:
            return None
        self.__intensity = [intensity]
        return self
    def addIntensity(self, intensity = 1):
        if intensity == None or intensity  <  0:
            return None
        if intensity == None or intensity  >  1:
            return None
        if self.__intensity == None:            self.__intensity =  []
        self.__intensity +=  [intensity]
        return self
    def removeIntensity(self, intensity):
        self.__intensity = [x for x in self.__intensity if x not in intensity]
        return self.__intensity
    def getIntensity(self, intensity = 1):
        return self.__intensity
    def intensity_changed(self, intensity = 1):
        return self.__intensity
    @property
    def location(self):
        return self.__location
    @location.setter
    def location(self, value = [0, 0, 0]):
        self.__location = [value]
    def setLocation(self, location = [0, 0, 0]):
        self.__location = [location]
        return self
    def addLocation(self, location = [0, 0, 0]):
        if self.__location == None:            self.__location =  []
        self.__location +=  [location]
        return self
    def removeLocation(self, location):
        self.__location = [x for x in self.__location if x not in location]
        return self.__location
    def getLocation(self, location = [0, 0, 0]):
        return self.__location
    def location_changed(self, location = [0, 0, 0]):
        return self.__location
    @property
    def maxBack(self):
        return self.__maxBack
    @maxBack.setter
    def maxBack(self, value = 10):
        if value == None or value  <  0:
            return None
        self.__maxBack = [value]
    def setMaxBack(self, maxBack = 10):
        if maxBack == None or maxBack  <  0:
            return None
        self.__maxBack = [maxBack]
        return self
    def addMaxBack(self, maxBack = 10):
        if maxBack == None or maxBack  <  0:
            return None
        if self.__maxBack == None:            self.__maxBack =  []
        self.__maxBack +=  [maxBack]
        return self
    def removeMaxBack(self, maxBack):
        self.__maxBack = [x for x in self.__maxBack if x not in maxBack]
        return self.__maxBack
    def getMaxBack(self, maxBack = 10):
        return self.__maxBack
    def maxBack_changed(self, maxBack = 10):
        return self.__maxBack
    @property
    def maxFront(self):
        return self.__maxFront
    @maxFront.setter
    def maxFront(self, value = 10):
        if value == None or value  <  0:
            return None
        self.__maxFront = [value]
    def setMaxFront(self, maxFront = 10):
        if maxFront == None or maxFront  <  0:
            return None
        self.__maxFront = [maxFront]
        return self
    def addMaxFront(self, maxFront = 10):
        if maxFront == None or maxFront  <  0:
            return None
        if self.__maxFront == None:            self.__maxFront =  []
        self.__maxFront +=  [maxFront]
        return self
    def removeMaxFront(self, maxFront):
        self.__maxFront = [x for x in self.__maxFront if x not in maxFront]
        return self.__maxFront
    def getMaxFront(self, maxFront = 10):
        return self.__maxFront
    def maxFront_changed(self, maxFront = 10):
        return self.__maxFront
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def minBack(self):
        return self.__minBack
    @minBack.setter
    def minBack(self, value = 1):
        if value == None or value  <  0:
            return None
        self.__minBack = [value]
    def setMinBack(self, minBack = 1):
        if minBack == None or minBack  <  0:
            return None
        self.__minBack = [minBack]
        return self
    def addMinBack(self, minBack = 1):
        if minBack == None or minBack  <  0:
            return None
        if self.__minBack == None:            self.__minBack =  []
        self.__minBack +=  [minBack]
        return self
    def removeMinBack(self, minBack):
        self.__minBack = [x for x in self.__minBack if x not in minBack]
        return self.__minBack
    def getMinBack(self, minBack = 1):
        return self.__minBack
    def minBack_changed(self, minBack = 1):
        return self.__minBack
    @property
    def minFront(self):
        return self.__minFront
    @minFront.setter
    def minFront(self, value = 1):
        if value == None or value  <  0:
            return None
        self.__minFront = [value]
    def setMinFront(self, minFront = 1):
        if minFront == None or minFront  <  0:
            return None
        self.__minFront = [minFront]
        return self
    def addMinFront(self, minFront = 1):
        if minFront == None or minFront  <  0:
            return None
        if self.__minFront == None:            self.__minFront =  []
        self.__minFront +=  [minFront]
        return self
    def removeMinFront(self, minFront):
        self.__minFront = [x for x in self.__minFront if x not in minFront]
        return self.__minFront
    def getMinFront(self, minFront = 1):
        return self.__minFront
    def minFront_changed(self, minFront = 1):
        return self.__minFront
    @property
    def priority(self):
        return self.__priority
    @priority.setter
    def priority(self, value = 0):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__priority = [value]
    def setPriority(self, priority = 0):
        if priority == None or priority  <  0:
            return None
        if priority == None or priority  >  1:
            return None
        self.__priority = [priority]
        return self
    def addPriority(self, priority = 0):
        if priority == None or priority  <  0:
            return None
        if priority == None or priority  >  1:
            return None
        if self.__priority == None:            self.__priority =  []
        self.__priority +=  [priority]
        return self
    def removePriority(self, priority):
        self.__priority = [x for x in self.__priority if x not in priority]
        return self.__priority
    def getPriority(self, priority = 0):
        return self.__priority
    def priority_changed(self, priority = 0):
        return self.__priority
    @property
    def source(self):
        return self.__source
    @source.setter
    def source(self, value = None):
        self.__source = [value]
    def setSource(self, source = None):
        self.__source = [source]
        return self
    def addSource(self, source = None):
        if self.__source == None:            self.__source =  []
        self.__source +=  [source]
        return self
    def removeSource(self, source):
        self.__source = [x for x in self.__source if x not in source]
        return self.__source
    def getSource(self, source = None):
        return self.__source
    def source_changed(self, source = None):
        return self.__source
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Sound'
        if self.__direction is not None:
            if isinstance(self.__direction, six.string_types):
                str += ' direction="'+self.__direction+'"'
            else:
                str += ' direction="'+self.__direction[0]+'"'
        if self.__intensity is not None:
            if isinstance(self.__intensity, six.string_types):
                str += ' intensity="'+self.__intensity+'"'
            else:
                str += ' intensity="'+self.__intensity[0]+'"'
        if self.__location is not None:
            if isinstance(self.__location, six.string_types):
                str += ' location="'+self.__location+'"'
            else:
                str += ' location="'+self.__location[0]+'"'
        if self.__maxBack is not None:
            if isinstance(self.__maxBack, six.string_types):
                str += ' maxBack="'+self.__maxBack+'"'
            else:
                str += ' maxBack="'+self.__maxBack[0]+'"'
        if self.__maxFront is not None:
            if isinstance(self.__maxFront, six.string_types):
                str += ' maxFront="'+self.__maxFront+'"'
            else:
                str += ' maxFront="'+self.__maxFront[0]+'"'
        if self.__minBack is not None:
            if isinstance(self.__minBack, six.string_types):
                str += ' minBack="'+self.__minBack+'"'
            else:
                str += ' minBack="'+self.__minBack[0]+'"'
        if self.__minFront is not None:
            if isinstance(self.__minFront, six.string_types):
                str += ' minFront="'+self.__minFront+'"'
            else:
                str += ' minFront="'+self.__minFront[0]+'"'
        if self.__priority is not None:
            if isinstance(self.__priority, six.string_types):
                str += ' priority="'+self.__priority+'"'
            else:
                str += ' priority="'+self.__priority[0]+'"'
        if self.__spatialize is not None:
            if isinstance(self.__spatialize, six.string_types):
                str += ' spatialize="'+self.__spatialize+'"'
            else:
                str += ' spatialize="'+self.__spatialize[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<source'
        if self.__source is not None:
           for s in self.__source:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__source is not None:
           for s in self.__source:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</source>'
        str += '</Sound>'
        return str


class Sphere(X3DGeometryNode):
    def __init__(self, **kwargs):
        super(Sphere, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        radius  = kwargs.pop("radius", 1)
        if radius == None or radius  <=  0:
            return None
        self.__radius = radius
        solid  = kwargs.pop("solid", True)
        self.__solid = solid
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Sphere'
        if self.__radius is not None:
            if isinstance(self.__radius, six.string_types):
                str += ' radius="'+self.__radius+'"'
            else:
                str += ' radius="'+self.__radius[0]+'"'
        if self.__solid is not None:
            if isinstance(self.__solid, six.string_types):
                str += ' solid="'+self.__solid+'"'
            else:
                str += ' solid="'+self.__solid[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</Sphere>'
        return str


class SphereSensor(X3DDragSensorNode):
    def __init__(self, **kwargs):
        super(SphereSensor, self).__init__(**kwargs)
        autoOffset  = kwargs.pop("autoOffset", True)
        self.__autoOffset = autoOffset
        description  = kwargs.pop("description", None)
        self.__description = description
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        Over  = kwargs.pop("Over", None)
        self.__Over = Over
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        offset  = kwargs.pop("offset", [0, 1, 0, 0])
        self.__offset = offset
        rotation_changed  = kwargs.pop("rotation_changed", None)
        self.__rotation_changed = rotation_changed
        trackPoint_changed  = kwargs.pop("trackPoint_changed", None)
        self.__trackPoint_changed = trackPoint_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def autoOffset(self):
        return self.__autoOffset
    @autoOffset.setter
    def autoOffset(self, value = True):
        self.__autoOffset = [value]
    def setAutoOffset(self, autoOffset = True):
        self.__autoOffset = [autoOffset]
        return self
    def addAutoOffset(self, autoOffset = True):
        if self.__autoOffset == None:            self.__autoOffset =  []
        self.__autoOffset +=  [autoOffset]
        return self
    def removeAutoOffset(self, autoOffset):
        self.__autoOffset = [x for x in self.__autoOffset if x not in autoOffset]
        return self.__autoOffset
    def isAutoOffset(self, autoOffset = True):
        return self.__autoOffset
    @property
    def description(self):
        return self.__description
    @description.setter
    def description(self, value = None):
        self.__description = [value]
    def setDescription(self, description = None):
        self.__description = [description]
        return self
    def addDescription(self, description = None):
        if self.__description == None:            self.__description =  []
        self.__description +=  [description]
        return self
    def removeDescription(self, description):
        self.__description = [x for x in self.__description if x not in description]
        return self.__description
    def getDescription(self, description = None):
        return self.__description
    def description_changed(self, description = None):
        return self.__description
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    def isActive(self, Active = None):
        return self.__Active
    def isOver(self, Over = None):
        return self.__Over
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def offset(self):
        return self.__offset
    @offset.setter
    def offset(self, value = [0, 1, 0, 0]):
        self.__offset = [value]
    def setOffset(self, offset = [0, 1, 0, 0]):
        self.__offset = [offset]
        return self
    def addOffset(self, offset = [0, 1, 0, 0]):
        if self.__offset == None:            self.__offset =  []
        self.__offset +=  [offset]
        return self
    def removeOffset(self, offset):
        self.__offset = [x for x in self.__offset if x not in offset]
        return self.__offset
    def getOffset(self, offset = [0, 1, 0, 0]):
        return self.__offset
    def offset_changed(self, offset = [0, 1, 0, 0]):
        return self.__offset
    def removerotation_changed(self, rotation_changed):
        self.__rotation_changed = [x for x in self.__rotation_changed if x not in rotation_changed]
        return self.__rotation_changed
    def getrotation_changed(self, rotation_changed = None):
        return self.__rotation_changed
    def rotation_changed_changed(self, rotation_changed = None):
        return self.__rotation_changed
    def removetrackPoint_changed(self, trackPoint_changed):
        self.__trackPoint_changed = [x for x in self.__trackPoint_changed if x not in trackPoint_changed]
        return self.__trackPoint_changed
    def gettrackPoint_changed(self, trackPoint_changed = None):
        return self.__trackPoint_changed
    def trackPoint_changed_changed(self, trackPoint_changed = None):
        return self.__trackPoint_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<SphereSensor'
        if self.__autoOffset is not None:
            if isinstance(self.__autoOffset, six.string_types):
                str += ' autoOffset="'+self.__autoOffset+'"'
            else:
                str += ' autoOffset="'+self.__autoOffset[0]+'"'
        if self.__description is not None:
            if isinstance(self.__description, six.string_types):
                str += ' description="'+self.__description+'"'
            else:
                str += ' description="'+self.__description[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__Over is not None:
            if isinstance(self.__Over, six.string_types):
                str += ' Over="'+self.__Over+'"'
            else:
                str += ' Over="'+self.__Over[0]+'"'
        if self.__offset is not None:
            if isinstance(self.__offset, six.string_types):
                str += ' offset="'+self.__offset+'"'
            else:
                str += ' offset="'+self.__offset[0]+'"'
        if self.__rotation_changed is not None:
            if isinstance(self.__rotation_changed, six.string_types):
                str += ' rotation_changed="'+self.__rotation_changed+'"'
            else:
                str += ' rotation_changed="'+self.__rotation_changed[0]+'"'
        if self.__trackPoint_changed is not None:
            if isinstance(self.__trackPoint_changed, six.string_types):
                str += ' trackPoint_changed="'+self.__trackPoint_changed+'"'
            else:
                str += ' trackPoint_changed="'+self.__trackPoint_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</SphereSensor>'
        return str


class SplinePositionInterpolator(X3DInterpolatorNode):
    def __init__(self, **kwargs):
        super(SplinePositionInterpolator, self).__init__(**kwargs)
        closed  = kwargs.pop("closed", False)
        self.__closed = closed
        key  = kwargs.pop("key", None)
        self.__key = key
        keyValue  = kwargs.pop("keyValue", None)
        self.__keyValue = keyValue
        keyVelocity  = kwargs.pop("keyVelocity", None)
        self.__keyVelocity = keyVelocity
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        normalizeVelocity  = kwargs.pop("normalizeVelocity", False)
        self.__normalizeVelocity = normalizeVelocity
        fraction  = kwargs.pop("fraction", None)
        self.__fraction = fraction
        value_changed  = kwargs.pop("value_changed", None)
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def key(self):
        return self.__key
    @key.setter
    def key(self, value = None):
        self.__key = [value]
    def setKey(self, key = None):
        self.__key = [key]
        return self
    def addKey(self, key = None):
        if self.__key == None:            self.__key =  []
        self.__key +=  [key]
        return self
    def removeKey(self, key):
        self.__key = [x for x in self.__key if x not in key]
        return self.__key
    def getKey(self, key = None):
        return self.__key
    def key_changed(self, key = None):
        return self.__key
    @property
    def keyValue(self):
        return self.__keyValue
    @keyValue.setter
    def keyValue(self, value = None):
        self.__keyValue = [value]
    def setKeyValue(self, keyValue = None):
        self.__keyValue = [keyValue]
        return self
    def addKeyValue(self, keyValue = None):
        if self.__keyValue == None:            self.__keyValue =  []
        self.__keyValue +=  [keyValue]
        return self
    def removeKeyValue(self, keyValue):
        self.__keyValue = [x for x in self.__keyValue if x not in keyValue]
        return self.__keyValue
    def getKeyValue(self, keyValue = None):
        return self.__keyValue
    def keyValue_changed(self, keyValue = None):
        return self.__keyValue
    @property
    def keyVelocity(self):
        return self.__keyVelocity
    @keyVelocity.setter
    def keyVelocity(self, value = None):
        self.__keyVelocity = [value]
    def setKeyVelocity(self, keyVelocity = None):
        self.__keyVelocity = [keyVelocity]
        return self
    def addKeyVelocity(self, keyVelocity = None):
        if self.__keyVelocity == None:            self.__keyVelocity =  []
        self.__keyVelocity +=  [keyVelocity]
        return self
    def removeKeyVelocity(self, keyVelocity):
        self.__keyVelocity = [x for x in self.__keyVelocity if x not in keyVelocity]
        return self.__keyVelocity
    def getKeyVelocity(self, keyVelocity = None):
        return self.__keyVelocity
    def keyVelocity_changed(self, keyVelocity = None):
        return self.__keyVelocity
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def normalizeVelocity(self):
        return self.__normalizeVelocity
    @normalizeVelocity.setter
    def normalizeVelocity(self, value = False):
        self.__normalizeVelocity = [value]
    def setNormalizeVelocity(self, normalizeVelocity = False):
        self.__normalizeVelocity = [normalizeVelocity]
        return self
    def addNormalizeVelocity(self, normalizeVelocity = False):
        if self.__normalizeVelocity == None:            self.__normalizeVelocity =  []
        self.__normalizeVelocity +=  [normalizeVelocity]
        return self
    def removeNormalizeVelocity(self, normalizeVelocity):
        self.__normalizeVelocity = [x for x in self.__normalizeVelocity if x not in normalizeVelocity]
        return self.__normalizeVelocity
    def isNormalizeVelocity(self, normalizeVelocity = False):
        return self.__normalizeVelocity
    @property
    def fraction(self):
        return self.__fraction
    @fraction.setter
    def fraction(self, value = None):
        self.__fraction = [value]
    def set_fraction(self, fraction = None):
        self.__fraction = [fraction]
        return self
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<SplinePositionInterpolator'
        if self.__closed is not None:
            if isinstance(self.__closed, six.string_types):
                str += ' closed="'+self.__closed+'"'
            else:
                str += ' closed="'+self.__closed[0]+'"'
        if self.__key is not None:
            if isinstance(self.__key, six.string_types):
                str += ' key="'+self.__key+'"'
            else:
                str += ' key="'+self.__key[0]+'"'
        if self.__keyValue is not None:
            if isinstance(self.__keyValue, six.string_types):
                str += ' keyValue="'+self.__keyValue+'"'
            else:
                str += ' keyValue="'+self.__keyValue[0]+'"'
        if self.__keyVelocity is not None:
            if isinstance(self.__keyVelocity, six.string_types):
                str += ' keyVelocity="'+self.__keyVelocity+'"'
            else:
                str += ' keyVelocity="'+self.__keyVelocity[0]+'"'
        if self.__normalizeVelocity is not None:
            if isinstance(self.__normalizeVelocity, six.string_types):
                str += ' normalizeVelocity="'+self.__normalizeVelocity+'"'
            else:
                str += ' normalizeVelocity="'+self.__normalizeVelocity[0]+'"'
        if self.__fraction is not None:
            if isinstance(self.__fraction, six.string_types):
                str += ' fraction="'+self.__fraction+'"'
            else:
                str += ' fraction="'+self.__fraction[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</SplinePositionInterpolator>'
        return str


class SplinePositionInterpolator2D(X3DInterpolatorNode):
    def __init__(self, **kwargs):
        super(SplinePositionInterpolator2D, self).__init__(**kwargs)
        closed  = kwargs.pop("closed", False)
        self.__closed = closed
        key  = kwargs.pop("key", None)
        self.__key = key
        keyValue  = kwargs.pop("keyValue", None)
        self.__keyValue = keyValue
        keyVelocity  = kwargs.pop("keyVelocity", None)
        self.__keyVelocity = keyVelocity
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        normalizeVelocity  = kwargs.pop("normalizeVelocity", False)
        self.__normalizeVelocity = normalizeVelocity
        fraction  = kwargs.pop("fraction", None)
        self.__fraction = fraction
        value_changed  = kwargs.pop("value_changed", None)
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def key(self):
        return self.__key
    @key.setter
    def key(self, value = None):
        self.__key = [value]
    def setKey(self, key = None):
        self.__key = [key]
        return self
    def addKey(self, key = None):
        if self.__key == None:            self.__key =  []
        self.__key +=  [key]
        return self
    def removeKey(self, key):
        self.__key = [x for x in self.__key if x not in key]
        return self.__key
    def getKey(self, key = None):
        return self.__key
    def key_changed(self, key = None):
        return self.__key
    @property
    def keyValue(self):
        return self.__keyValue
    @keyValue.setter
    def keyValue(self, value = None):
        self.__keyValue = [value]
    def setKeyValue(self, keyValue = None):
        self.__keyValue = [keyValue]
        return self
    def addKeyValue(self, keyValue = None):
        if self.__keyValue == None:            self.__keyValue =  []
        self.__keyValue +=  [keyValue]
        return self
    def removeKeyValue(self, keyValue):
        self.__keyValue = [x for x in self.__keyValue if x not in keyValue]
        return self.__keyValue
    def getKeyValue(self, keyValue = None):
        return self.__keyValue
    def keyValue_changed(self, keyValue = None):
        return self.__keyValue
    @property
    def keyVelocity(self):
        return self.__keyVelocity
    @keyVelocity.setter
    def keyVelocity(self, value = None):
        self.__keyVelocity = [value]
    def setKeyVelocity(self, keyVelocity = None):
        self.__keyVelocity = [keyVelocity]
        return self
    def addKeyVelocity(self, keyVelocity = None):
        if self.__keyVelocity == None:            self.__keyVelocity =  []
        self.__keyVelocity +=  [keyVelocity]
        return self
    def removeKeyVelocity(self, keyVelocity):
        self.__keyVelocity = [x for x in self.__keyVelocity if x not in keyVelocity]
        return self.__keyVelocity
    def getKeyVelocity(self, keyVelocity = None):
        return self.__keyVelocity
    def keyVelocity_changed(self, keyVelocity = None):
        return self.__keyVelocity
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def normalizeVelocity(self):
        return self.__normalizeVelocity
    @normalizeVelocity.setter
    def normalizeVelocity(self, value = False):
        self.__normalizeVelocity = [value]
    def setNormalizeVelocity(self, normalizeVelocity = False):
        self.__normalizeVelocity = [normalizeVelocity]
        return self
    def addNormalizeVelocity(self, normalizeVelocity = False):
        if self.__normalizeVelocity == None:            self.__normalizeVelocity =  []
        self.__normalizeVelocity +=  [normalizeVelocity]
        return self
    def removeNormalizeVelocity(self, normalizeVelocity):
        self.__normalizeVelocity = [x for x in self.__normalizeVelocity if x not in normalizeVelocity]
        return self.__normalizeVelocity
    def isNormalizeVelocity(self, normalizeVelocity = False):
        return self.__normalizeVelocity
    @property
    def fraction(self):
        return self.__fraction
    @fraction.setter
    def fraction(self, value = None):
        self.__fraction = [value]
    def set_fraction(self, fraction = None):
        self.__fraction = [fraction]
        return self
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<SplinePositionInterpolator2D'
        if self.__closed is not None:
            if isinstance(self.__closed, six.string_types):
                str += ' closed="'+self.__closed+'"'
            else:
                str += ' closed="'+self.__closed[0]+'"'
        if self.__key is not None:
            if isinstance(self.__key, six.string_types):
                str += ' key="'+self.__key+'"'
            else:
                str += ' key="'+self.__key[0]+'"'
        if self.__keyValue is not None:
            if isinstance(self.__keyValue, six.string_types):
                str += ' keyValue="'+self.__keyValue+'"'
            else:
                str += ' keyValue="'+self.__keyValue[0]+'"'
        if self.__keyVelocity is not None:
            if isinstance(self.__keyVelocity, six.string_types):
                str += ' keyVelocity="'+self.__keyVelocity+'"'
            else:
                str += ' keyVelocity="'+self.__keyVelocity[0]+'"'
        if self.__normalizeVelocity is not None:
            if isinstance(self.__normalizeVelocity, six.string_types):
                str += ' normalizeVelocity="'+self.__normalizeVelocity+'"'
            else:
                str += ' normalizeVelocity="'+self.__normalizeVelocity[0]+'"'
        if self.__fraction is not None:
            if isinstance(self.__fraction, six.string_types):
                str += ' fraction="'+self.__fraction+'"'
            else:
                str += ' fraction="'+self.__fraction[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</SplinePositionInterpolator2D>'
        return str


class SplineScalarInterpolator(X3DInterpolatorNode):
    def __init__(self, **kwargs):
        super(SplineScalarInterpolator, self).__init__(**kwargs)
        closed  = kwargs.pop("closed", False)
        self.__closed = closed
        key  = kwargs.pop("key", None)
        self.__key = key
        keyValue  = kwargs.pop("keyValue", None)
        self.__keyValue = keyValue
        keyVelocity  = kwargs.pop("keyVelocity", None)
        self.__keyVelocity = keyVelocity
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        normalizeVelocity  = kwargs.pop("normalizeVelocity", False)
        self.__normalizeVelocity = normalizeVelocity
        fraction  = kwargs.pop("fraction", None)
        self.__fraction = fraction
        value_changed  = kwargs.pop("value_changed", None)
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def key(self):
        return self.__key
    @key.setter
    def key(self, value = None):
        self.__key = [value]
    def setKey(self, key = None):
        self.__key = [key]
        return self
    def addKey(self, key = None):
        if self.__key == None:            self.__key =  []
        self.__key +=  [key]
        return self
    def removeKey(self, key):
        self.__key = [x for x in self.__key if x not in key]
        return self.__key
    def getKey(self, key = None):
        return self.__key
    def key_changed(self, key = None):
        return self.__key
    @property
    def keyValue(self):
        return self.__keyValue
    @keyValue.setter
    def keyValue(self, value = None):
        self.__keyValue = [value]
    def setKeyValue(self, keyValue = None):
        self.__keyValue = [keyValue]
        return self
    def addKeyValue(self, keyValue = None):
        if self.__keyValue == None:            self.__keyValue =  []
        self.__keyValue +=  [keyValue]
        return self
    def removeKeyValue(self, keyValue):
        self.__keyValue = [x for x in self.__keyValue if x not in keyValue]
        return self.__keyValue
    def getKeyValue(self, keyValue = None):
        return self.__keyValue
    def keyValue_changed(self, keyValue = None):
        return self.__keyValue
    @property
    def keyVelocity(self):
        return self.__keyVelocity
    @keyVelocity.setter
    def keyVelocity(self, value = None):
        self.__keyVelocity = [value]
    def setKeyVelocity(self, keyVelocity = None):
        self.__keyVelocity = [keyVelocity]
        return self
    def addKeyVelocity(self, keyVelocity = None):
        if self.__keyVelocity == None:            self.__keyVelocity =  []
        self.__keyVelocity +=  [keyVelocity]
        return self
    def removeKeyVelocity(self, keyVelocity):
        self.__keyVelocity = [x for x in self.__keyVelocity if x not in keyVelocity]
        return self.__keyVelocity
    def getKeyVelocity(self, keyVelocity = None):
        return self.__keyVelocity
    def keyVelocity_changed(self, keyVelocity = None):
        return self.__keyVelocity
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def normalizeVelocity(self):
        return self.__normalizeVelocity
    @normalizeVelocity.setter
    def normalizeVelocity(self, value = False):
        self.__normalizeVelocity = [value]
    def setNormalizeVelocity(self, normalizeVelocity = False):
        self.__normalizeVelocity = [normalizeVelocity]
        return self
    def addNormalizeVelocity(self, normalizeVelocity = False):
        if self.__normalizeVelocity == None:            self.__normalizeVelocity =  []
        self.__normalizeVelocity +=  [normalizeVelocity]
        return self
    def removeNormalizeVelocity(self, normalizeVelocity):
        self.__normalizeVelocity = [x for x in self.__normalizeVelocity if x not in normalizeVelocity]
        return self.__normalizeVelocity
    def isNormalizeVelocity(self, normalizeVelocity = False):
        return self.__normalizeVelocity
    @property
    def fraction(self):
        return self.__fraction
    @fraction.setter
    def fraction(self, value = None):
        self.__fraction = [value]
    def set_fraction(self, fraction = None):
        self.__fraction = [fraction]
        return self
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<SplineScalarInterpolator'
        if self.__closed is not None:
            if isinstance(self.__closed, six.string_types):
                str += ' closed="'+self.__closed+'"'
            else:
                str += ' closed="'+self.__closed[0]+'"'
        if self.__key is not None:
            if isinstance(self.__key, six.string_types):
                str += ' key="'+self.__key+'"'
            else:
                str += ' key="'+self.__key[0]+'"'
        if self.__keyValue is not None:
            if isinstance(self.__keyValue, six.string_types):
                str += ' keyValue="'+self.__keyValue+'"'
            else:
                str += ' keyValue="'+self.__keyValue[0]+'"'
        if self.__keyVelocity is not None:
            if isinstance(self.__keyVelocity, six.string_types):
                str += ' keyVelocity="'+self.__keyVelocity+'"'
            else:
                str += ' keyVelocity="'+self.__keyVelocity[0]+'"'
        if self.__normalizeVelocity is not None:
            if isinstance(self.__normalizeVelocity, six.string_types):
                str += ' normalizeVelocity="'+self.__normalizeVelocity+'"'
            else:
                str += ' normalizeVelocity="'+self.__normalizeVelocity[0]+'"'
        if self.__fraction is not None:
            if isinstance(self.__fraction, six.string_types):
                str += ' fraction="'+self.__fraction+'"'
            else:
                str += ' fraction="'+self.__fraction[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</SplineScalarInterpolator>'
        return str


class SpotLight(X3DLightNode):
    def __init__(self, **kwargs):
        super(SpotLight, self).__init__(**kwargs)
        ambientIntensity  = kwargs.pop("ambientIntensity", 0)
        if ambientIntensity == None or ambientIntensity  <  0:
            return None
        if ambientIntensity == None or ambientIntensity  >  1:
            return None
        self.__ambientIntensity = ambientIntensity
        attenuation  = kwargs.pop("attenuation", [1, 0, 0])
        if attenuation == None or len(attenuation) <= 0 or min(attenuation)  <  0:
            return None
        self.__attenuation = attenuation
        beamWidth  = kwargs.pop("beamWidth", 0.7854)
        if beamWidth == None or beamWidth  >  1.570796:
            return None
        if beamWidth == None or beamWidth  <=  0:
            return None
        self.__beamWidth = beamWidth
        color  = kwargs.pop("color", [1, 1, 1])
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        self.__color = color
        cutOffAngle  = kwargs.pop("cutOffAngle", 1.570796)
        if cutOffAngle == None or cutOffAngle  >  1.570796:
            return None
        if cutOffAngle == None or cutOffAngle  <=  0:
            return None
        self.__cutOffAngle = cutOffAngle
        direction  = kwargs.pop("direction", [0, 0, -1])
        self.__direction = direction
        global_  = kwargs.pop("global_", True)
        self.__global_ = global_
        intensity  = kwargs.pop("intensity", 1)
        if intensity == None or intensity  <  0:
            return None
        if intensity == None or intensity  >  1:
            return None
        self.__intensity = intensity
        location  = kwargs.pop("location", [0, 0, 0])
        self.__location = location
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        on  = kwargs.pop("on", True)
        self.__on = on
        radius  = kwargs.pop("radius", 100)
        if radius == None or radius  <  0:
            return None
        self.__radius = radius
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def ambientIntensity(self):
        return self.__ambientIntensity
    @ambientIntensity.setter
    def ambientIntensity(self, value = 0):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__ambientIntensity = [value]
    def setAmbientIntensity(self, ambientIntensity = 0):
        if ambientIntensity == None or ambientIntensity  <  0:
            return None
        if ambientIntensity == None or ambientIntensity  >  1:
            return None
        self.__ambientIntensity = [ambientIntensity]
        return self
    def addAmbientIntensity(self, ambientIntensity = 0):
        if ambientIntensity == None or ambientIntensity  <  0:
            return None
        if ambientIntensity == None or ambientIntensity  >  1:
            return None
        if self.__ambientIntensity == None:            self.__ambientIntensity =  []
        self.__ambientIntensity +=  [ambientIntensity]
        return self
    def removeAmbientIntensity(self, ambientIntensity):
        self.__ambientIntensity = [x for x in self.__ambientIntensity if x not in ambientIntensity]
        return self.__ambientIntensity
    def getAmbientIntensity(self, ambientIntensity = 0):
        return self.__ambientIntensity
    def ambientIntensity_changed(self, ambientIntensity = 0):
        return self.__ambientIntensity
    @property
    def attenuation(self):
        return self.__attenuation
    @attenuation.setter
    def attenuation(self, value = [1, 0, 0]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        self.__attenuation = [value]
    def setAttenuation(self, attenuation = [1, 0, 0]):
        if attenuation == None or len(attenuation) <= 0 or min(attenuation)  <  0:
            return None
        self.__attenuation = [attenuation]
        return self
    def addAttenuation(self, attenuation = [1, 0, 0]):
        if attenuation == None or len(attenuation) <= 0 or min(attenuation)  <  0:
            return None
        if self.__attenuation == None:            self.__attenuation =  []
        self.__attenuation +=  [attenuation]
        return self
    def removeAttenuation(self, attenuation):
        self.__attenuation = [x for x in self.__attenuation if x not in attenuation]
        return self.__attenuation
    def getAttenuation(self, attenuation = [1, 0, 0]):
        return self.__attenuation
    def attenuation_changed(self, attenuation = [1, 0, 0]):
        return self.__attenuation
    @property
    def beamWidth(self):
        return self.__beamWidth
    @beamWidth.setter
    def beamWidth(self, value = 0.7854):
        if value == None or value  >  1.570796:
            return None
        if value == None or value  <=  0:
            return None
        self.__beamWidth = [value]
    def setBeamWidth(self, beamWidth = 0.7854):
        if beamWidth == None or beamWidth  >  1.570796:
            return None
        if beamWidth == None or beamWidth  <=  0:
            return None
        self.__beamWidth = [beamWidth]
        return self
    def addBeamWidth(self, beamWidth = 0.7854):
        if beamWidth == None or beamWidth  >  1.570796:
            return None
        if beamWidth == None or beamWidth  <=  0:
            return None
        if self.__beamWidth == None:            self.__beamWidth =  []
        self.__beamWidth +=  [beamWidth]
        return self
    def removeBeamWidth(self, beamWidth):
        self.__beamWidth = [x for x in self.__beamWidth if x not in beamWidth]
        return self.__beamWidth
    def getBeamWidth(self, beamWidth = 0.7854):
        return self.__beamWidth
    def beamWidth_changed(self, beamWidth = 0.7854):
        return self.__beamWidth
    @property
    def color(self):
        return self.__color
    @color.setter
    def color(self, value = [1, 1, 1]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__color = [value]
    def setColor(self, color = [1, 1, 1]):
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        self.__color = [color]
        return self
    def addColor(self, color = [1, 1, 1]):
        if color == None or len(color) <= 0 or min(color)  <  0:
            return None
        if color == None or len(color) <= 0 or max(color)  >  1:
            return None
        if self.__color == None:            self.__color =  []
        self.__color +=  [color]
        return self
    def removeColor(self, color):
        self.__color = [x for x in self.__color if x not in color]
        return self.__color
    def getColor(self, color = [1, 1, 1]):
        return self.__color
    def color_changed(self, color = [1, 1, 1]):
        return self.__color
    @property
    def cutOffAngle(self):
        return self.__cutOffAngle
    @cutOffAngle.setter
    def cutOffAngle(self, value = 1.570796):
        if value == None or value  >  1.570796:
            return None
        if value == None or value  <=  0:
            return None
        self.__cutOffAngle = [value]
    def setCutOffAngle(self, cutOffAngle = 1.570796):
        if cutOffAngle == None or cutOffAngle  >  1.570796:
            return None
        if cutOffAngle == None or cutOffAngle  <=  0:
            return None
        self.__cutOffAngle = [cutOffAngle]
        return self
    def addCutOffAngle(self, cutOffAngle = 1.570796):
        if cutOffAngle == None or cutOffAngle  >  1.570796:
            return None
        if cutOffAngle == None or cutOffAngle  <=  0:
            return None
        if self.__cutOffAngle == None:            self.__cutOffAngle =  []
        self.__cutOffAngle +=  [cutOffAngle]
        return self
    def removeCutOffAngle(self, cutOffAngle):
        self.__cutOffAngle = [x for x in self.__cutOffAngle if x not in cutOffAngle]
        return self.__cutOffAngle
    def getCutOffAngle(self, cutOffAngle = 1.570796):
        return self.__cutOffAngle
    def cutOffAngle_changed(self, cutOffAngle = 1.570796):
        return self.__cutOffAngle
    @property
    def direction(self):
        return self.__direction
    @direction.setter
    def direction(self, value = [0, 0, -1]):
        self.__direction = [value]
    def setDirection(self, direction = [0, 0, -1]):
        self.__direction = [direction]
        return self
    def addDirection(self, direction = [0, 0, -1]):
        if self.__direction == None:            self.__direction =  []
        self.__direction +=  [direction]
        return self
    def removeDirection(self, direction):
        self.__direction = [x for x in self.__direction if x not in direction]
        return self.__direction
    def getDirection(self, direction = [0, 0, -1]):
        return self.__direction
    def direction_changed(self, direction = [0, 0, -1]):
        return self.__direction
    @property
    def global_(self):
        return self.__global_
    @global_.setter
    def global_(self, value = True):
        self.__global_ = [value]
    def setGlobal(self, global_ = True):
        self.__global_ = [global_]
        return self
    def addGlobal(self, global_ = True):
        if self.__global_ == None:            self.__global_ =  []
        self.__global_ +=  [global_]
        return self
    def removeGlobal(self, global_):
        self.__global_ = [x for x in self.__global_ if x not in global_]
        return self.__global_
    def isGlobal(self, global_ = True):
        return self.__global_
    @property
    def intensity(self):
        return self.__intensity
    @intensity.setter
    def intensity(self, value = 1):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__intensity = [value]
    def setIntensity(self, intensity = 1):
        if intensity == None or intensity  <  0:
            return None
        if intensity == None or intensity  >  1:
            return None
        self.__intensity = [intensity]
        return self
    def addIntensity(self, intensity = 1):
        if intensity == None or intensity  <  0:
            return None
        if intensity == None or intensity  >  1:
            return None
        if self.__intensity == None:            self.__intensity =  []
        self.__intensity +=  [intensity]
        return self
    def removeIntensity(self, intensity):
        self.__intensity = [x for x in self.__intensity if x not in intensity]
        return self.__intensity
    def getIntensity(self, intensity = 1):
        return self.__intensity
    def intensity_changed(self, intensity = 1):
        return self.__intensity
    @property
    def location(self):
        return self.__location
    @location.setter
    def location(self, value = [0, 0, 0]):
        self.__location = [value]
    def setLocation(self, location = [0, 0, 0]):
        self.__location = [location]
        return self
    def addLocation(self, location = [0, 0, 0]):
        if self.__location == None:            self.__location =  []
        self.__location +=  [location]
        return self
    def removeLocation(self, location):
        self.__location = [x for x in self.__location if x not in location]
        return self.__location
    def getLocation(self, location = [0, 0, 0]):
        return self.__location
    def location_changed(self, location = [0, 0, 0]):
        return self.__location
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def on(self):
        return self.__on
    @on.setter
    def on(self, value = True):
        self.__on = [value]
    def setOn(self, on = True):
        self.__on = [on]
        return self
    def addOn(self, on = True):
        if self.__on == None:            self.__on =  []
        self.__on +=  [on]
        return self
    def removeOn(self, on):
        self.__on = [x for x in self.__on if x not in on]
        return self.__on
    def isOn(self, on = True):
        return self.__on
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<SpotLight'
        if self.__ambientIntensity is not None:
            if isinstance(self.__ambientIntensity, six.string_types):
                str += ' ambientIntensity="'+self.__ambientIntensity+'"'
            else:
                str += ' ambientIntensity="'+self.__ambientIntensity[0]+'"'
        if self.__attenuation is not None:
            if isinstance(self.__attenuation, six.string_types):
                str += ' attenuation="'+self.__attenuation+'"'
            else:
                str += ' attenuation="'+self.__attenuation[0]+'"'
        if self.__beamWidth is not None:
            if isinstance(self.__beamWidth, six.string_types):
                str += ' beamWidth="'+self.__beamWidth+'"'
            else:
                str += ' beamWidth="'+self.__beamWidth[0]+'"'
        if self.__color is not None:
            if isinstance(self.__color, six.string_types):
                str += ' color="'+self.__color+'"'
            else:
                str += ' color="'+self.__color[0]+'"'
        if self.__cutOffAngle is not None:
            if isinstance(self.__cutOffAngle, six.string_types):
                str += ' cutOffAngle="'+self.__cutOffAngle+'"'
            else:
                str += ' cutOffAngle="'+self.__cutOffAngle[0]+'"'
        if self.__direction is not None:
            if isinstance(self.__direction, six.string_types):
                str += ' direction="'+self.__direction+'"'
            else:
                str += ' direction="'+self.__direction[0]+'"'
        if self.__global_ is not None:
            if isinstance(self.__global_, six.string_types):
                str += ' global_="'+self.__global_+'"'
            else:
                str += ' global_="'+self.__global_[0]+'"'
        if self.__intensity is not None:
            if isinstance(self.__intensity, six.string_types):
                str += ' intensity="'+self.__intensity+'"'
            else:
                str += ' intensity="'+self.__intensity[0]+'"'
        if self.__location is not None:
            if isinstance(self.__location, six.string_types):
                str += ' location="'+self.__location+'"'
            else:
                str += ' location="'+self.__location[0]+'"'
        if self.__on is not None:
            if isinstance(self.__on, six.string_types):
                str += ' on="'+self.__on+'"'
            else:
                str += ' on="'+self.__on[0]+'"'
        if self.__radius is not None:
            if isinstance(self.__radius, six.string_types):
                str += ' radius="'+self.__radius+'"'
            else:
                str += ' radius="'+self.__radius[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</SpotLight>'
        return str


class SquadOrientationInterpolator(X3DInterpolatorNode):
    def __init__(self, **kwargs):
        super(SquadOrientationInterpolator, self).__init__(**kwargs)
        key  = kwargs.pop("key", None)
        self.__key = key
        keyValue  = kwargs.pop("keyValue", None)
        self.__keyValue = keyValue
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        normalizeVelocity  = kwargs.pop("normalizeVelocity", False)
        self.__normalizeVelocity = normalizeVelocity
        fraction  = kwargs.pop("fraction", None)
        self.__fraction = fraction
        value_changed  = kwargs.pop("value_changed", None)
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def key(self):
        return self.__key
    @key.setter
    def key(self, value = None):
        self.__key = [value]
    def setKey(self, key = None):
        self.__key = [key]
        return self
    def addKey(self, key = None):
        if self.__key == None:            self.__key =  []
        self.__key +=  [key]
        return self
    def removeKey(self, key):
        self.__key = [x for x in self.__key if x not in key]
        return self.__key
    def getKey(self, key = None):
        return self.__key
    def key_changed(self, key = None):
        return self.__key
    @property
    def keyValue(self):
        return self.__keyValue
    @keyValue.setter
    def keyValue(self, value = None):
        self.__keyValue = [value]
    def setKeyValue(self, keyValue = None):
        self.__keyValue = [keyValue]
        return self
    def addKeyValue(self, keyValue = None):
        if self.__keyValue == None:            self.__keyValue =  []
        self.__keyValue +=  [keyValue]
        return self
    def removeKeyValue(self, keyValue):
        self.__keyValue = [x for x in self.__keyValue if x not in keyValue]
        return self.__keyValue
    def getKeyValue(self, keyValue = None):
        return self.__keyValue
    def keyValue_changed(self, keyValue = None):
        return self.__keyValue
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def normalizeVelocity(self):
        return self.__normalizeVelocity
    @normalizeVelocity.setter
    def normalizeVelocity(self, value = False):
        self.__normalizeVelocity = [value]
    def setNormalizeVelocity(self, normalizeVelocity = False):
        self.__normalizeVelocity = [normalizeVelocity]
        return self
    def addNormalizeVelocity(self, normalizeVelocity = False):
        if self.__normalizeVelocity == None:            self.__normalizeVelocity =  []
        self.__normalizeVelocity +=  [normalizeVelocity]
        return self
    def removeNormalizeVelocity(self, normalizeVelocity):
        self.__normalizeVelocity = [x for x in self.__normalizeVelocity if x not in normalizeVelocity]
        return self.__normalizeVelocity
    def isNormalizeVelocity(self, normalizeVelocity = False):
        return self.__normalizeVelocity
    @property
    def fraction(self):
        return self.__fraction
    @fraction.setter
    def fraction(self, value = None):
        self.__fraction = [value]
    def set_fraction(self, fraction = None):
        self.__fraction = [fraction]
        return self
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<SquadOrientationInterpolator'
        if self.__key is not None:
            if isinstance(self.__key, six.string_types):
                str += ' key="'+self.__key+'"'
            else:
                str += ' key="'+self.__key[0]+'"'
        if self.__keyValue is not None:
            if isinstance(self.__keyValue, six.string_types):
                str += ' keyValue="'+self.__keyValue+'"'
            else:
                str += ' keyValue="'+self.__keyValue[0]+'"'
        if self.__normalizeVelocity is not None:
            if isinstance(self.__normalizeVelocity, six.string_types):
                str += ' normalizeVelocity="'+self.__normalizeVelocity+'"'
            else:
                str += ' normalizeVelocity="'+self.__normalizeVelocity[0]+'"'
        if self.__fraction is not None:
            if isinstance(self.__fraction, six.string_types):
                str += ' fraction="'+self.__fraction+'"'
            else:
                str += ' fraction="'+self.__fraction[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</SquadOrientationInterpolator>'
        return str


class StaticGroup(X3DBoundedObject, X3DChildNode):
    def __init__(self, **kwargs):
        super(StaticGroup, self).__init__(**kwargs)
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        children  = kwargs.pop("children", None)
        self.__children = children
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<StaticGroup'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</StaticGroup>'
        return str


class StringSensor(X3DKeyDeviceSensorNode):
    def __init__(self, **kwargs):
        super(StringSensor, self).__init__(**kwargs)
        deletionAllowed  = kwargs.pop("deletionAllowed", True)
        self.__deletionAllowed = deletionAllowed
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        enteredText  = kwargs.pop("enteredText", None)
        self.__enteredText = enteredText
        finalText  = kwargs.pop("finalText", None)
        self.__finalText = finalText
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def deletionAllowed(self):
        return self.__deletionAllowed
    @deletionAllowed.setter
    def deletionAllowed(self, value = True):
        self.__deletionAllowed = [value]
    def setDeletionAllowed(self, deletionAllowed = True):
        self.__deletionAllowed = [deletionAllowed]
        return self
    def addDeletionAllowed(self, deletionAllowed = True):
        if self.__deletionAllowed == None:            self.__deletionAllowed =  []
        self.__deletionAllowed +=  [deletionAllowed]
        return self
    def removeDeletionAllowed(self, deletionAllowed):
        self.__deletionAllowed = [x for x in self.__deletionAllowed if x not in deletionAllowed]
        return self.__deletionAllowed
    def isDeletionAllowed(self, deletionAllowed = True):
        return self.__deletionAllowed
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    def removeEnteredText(self, enteredText):
        self.__enteredText = [x for x in self.__enteredText if x not in enteredText]
        return self.__enteredText
    def getEnteredText(self, enteredText = None):
        return self.__enteredText
    def enteredText_changed(self, enteredText = None):
        return self.__enteredText
    def removeFinalText(self, finalText):
        self.__finalText = [x for x in self.__finalText if x not in finalText]
        return self.__finalText
    def getFinalText(self, finalText = None):
        return self.__finalText
    def finalText_changed(self, finalText = None):
        return self.__finalText
    def isActive(self, Active = None):
        return self.__Active
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<StringSensor'
        if self.__deletionAllowed is not None:
            if isinstance(self.__deletionAllowed, six.string_types):
                str += ' deletionAllowed="'+self.__deletionAllowed+'"'
            else:
                str += ' deletionAllowed="'+self.__deletionAllowed[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__enteredText is not None:
            if isinstance(self.__enteredText, six.string_types):
                str += ' enteredText="'+self.__enteredText+'"'
            else:
                str += ' enteredText="'+self.__enteredText[0]+'"'
        if self.__finalText is not None:
            if isinstance(self.__finalText, six.string_types):
                str += ' finalText="'+self.__finalText+'"'
            else:
                str += ' finalText="'+self.__finalText[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</StringSensor>'
        return str


class SurfaceEmitter(X3DParticleEmitterNode):
    def __init__(self, **kwargs):
        super(SurfaceEmitter, self).__init__(**kwargs)
        coordIndex  = kwargs.pop("coordIndex", [-1])
        if coordIndex == None or len(coordIndex) <= 0 or min(coordIndex)  <  -1:
            return None
        self.__coordIndex = coordIndex
        mass  = kwargs.pop("mass", 0)
        if mass == None or mass  <  0:
            return None
        self.__mass = mass
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        coordIndex  = kwargs.pop("coordIndex", None)
        if coordIndex == None or len(coordIndex) <= 0 or min(coordIndex)  <  -1:
            return None
        self.__coordIndex = coordIndex
        speed  = kwargs.pop("speed", 0)
        if speed == None or speed  <  0:
            return None
        self.__speed = speed
        surface  = kwargs.pop("surface", None)
        self.__surface = surface
        surfaceArea  = kwargs.pop("surfaceArea", 0)
        if surfaceArea == None or surfaceArea  <  0:
            return None
        self.__surfaceArea = surfaceArea
        variation  = kwargs.pop("variation", 0.25)
        if variation == None or variation  <  0:
            return None
        self.__variation = variation
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def mass(self):
        return self.__mass
    @mass.setter
    def mass(self, value = 0):
        if value == None or value  <  0:
            return None
        self.__mass = [value]
    def setMass(self, mass = 0):
        if mass == None or mass  <  0:
            return None
        self.__mass = [mass]
        return self
    def addMass(self, mass = 0):
        if mass == None or mass  <  0:
            return None
        if self.__mass == None:            self.__mass =  []
        self.__mass +=  [mass]
        return self
    def removeMass(self, mass):
        self.__mass = [x for x in self.__mass if x not in mass]
        return self.__mass
    def getMass(self, mass = 0):
        return self.__mass
    def mass_changed(self, mass = 0):
        return self.__mass
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def coordIndex(self):
        return self.__coordIndex
    @coordIndex.setter
    def coordIndex(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  -1:
            return None
        self.__coordIndex = [value]
    def set_coordIndex(self, coordIndex = None):
        if coordIndex == None or len(coordIndex) <= 0 or min(coordIndex)  <  -1:
            return None
        self.__coordIndex = [coordIndex]
        return self
    @property
    def speed(self):
        return self.__speed
    @speed.setter
    def speed(self, value = 0):
        if value == None or value  <  0:
            return None
        self.__speed = [value]
    def setSpeed(self, speed = 0):
        if speed == None or speed  <  0:
            return None
        self.__speed = [speed]
        return self
    def addSpeed(self, speed = 0):
        if speed == None or speed  <  0:
            return None
        if self.__speed == None:            self.__speed =  []
        self.__speed +=  [speed]
        return self
    def removeSpeed(self, speed):
        self.__speed = [x for x in self.__speed if x not in speed]
        return self.__speed
    def getSpeed(self, speed = 0):
        return self.__speed
    def speed_changed(self, speed = 0):
        return self.__speed
    @property
    def variation(self):
        return self.__variation
    @variation.setter
    def variation(self, value = 0.25):
        if value == None or value  <  0:
            return None
        self.__variation = [value]
    def setVariation(self, variation = 0.25):
        if variation == None or variation  <  0:
            return None
        self.__variation = [variation]
        return self
    def addVariation(self, variation = 0.25):
        if variation == None or variation  <  0:
            return None
        if self.__variation == None:            self.__variation =  []
        self.__variation +=  [variation]
        return self
    def removeVariation(self, variation):
        self.__variation = [x for x in self.__variation if x not in variation]
        return self.__variation
    def getVariation(self, variation = 0.25):
        return self.__variation
    def variation_changed(self, variation = 0.25):
        return self.__variation
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<SurfaceEmitter'
        if self.__coordIndex is not None:
            if isinstance(self.__coordIndex, six.string_types):
                str += ' coordIndex="'+self.__coordIndex+'"'
            else:
                str += ' coordIndex="'+self.__coordIndex[0]+'"'
        if self.__mass is not None:
            if isinstance(self.__mass, six.string_types):
                str += ' mass="'+self.__mass+'"'
            else:
                str += ' mass="'+self.__mass[0]+'"'
        if self.__coordIndex is not None:
            if isinstance(self.__coordIndex, six.string_types):
                str += ' coordIndex="'+self.__coordIndex+'"'
            else:
                str += ' coordIndex="'+self.__coordIndex[0]+'"'
        if self.__speed is not None:
            if isinstance(self.__speed, six.string_types):
                str += ' speed="'+self.__speed+'"'
            else:
                str += ' speed="'+self.__speed[0]+'"'
        if self.__surfaceArea is not None:
            if isinstance(self.__surfaceArea, six.string_types):
                str += ' surfaceArea="'+self.__surfaceArea+'"'
            else:
                str += ' surfaceArea="'+self.__surfaceArea[0]+'"'
        if self.__variation is not None:
            if isinstance(self.__variation, six.string_types):
                str += ' variation="'+self.__variation+'"'
            else:
                str += ' variation="'+self.__variation[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<surface'
        if self.__surface is not None:
           for s in self.__surface:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__surface is not None:
           for s in self.__surface:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</surface>'
        str += '</SurfaceEmitter>'
        return str


class Switch(X3DGroupingNode):
    def __init__(self, **kwargs):
        super(Switch, self).__init__(**kwargs)
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        children  = kwargs.pop("children", None)
        self.__children = children
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        whichChoice  = kwargs.pop("whichChoice", -1)
        if whichChoice == None or whichChoice  <  -1:
            return None
        self.__whichChoice = whichChoice
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    def addChildren(self, Children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [Children]
        return self
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    @property
    def whichChoice(self):
        return self.__whichChoice
    @whichChoice.setter
    def whichChoice(self, value = -1):
        if value == None or value  <  -1:
            return None
        self.__whichChoice = [value]
    def setWhichChoice(self, whichChoice = -1):
        if whichChoice == None or whichChoice  <  -1:
            return None
        self.__whichChoice = [whichChoice]
        return self
    def addWhichChoice(self, whichChoice = -1):
        if whichChoice == None or whichChoice  <  -1:
            return None
        if self.__whichChoice == None:            self.__whichChoice =  []
        self.__whichChoice +=  [whichChoice]
        return self
    def removeWhichChoice(self, whichChoice):
        self.__whichChoice = [x for x in self.__whichChoice if x not in whichChoice]
        return self.__whichChoice
    def getWhichChoice(self, whichChoice = -1):
        return self.__whichChoice
    def whichChoice_changed(self, whichChoice = -1):
        return self.__whichChoice
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Switch'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__whichChoice is not None:
            if isinstance(self.__whichChoice, six.string_types):
                str += ' whichChoice="'+self.__whichChoice+'"'
            else:
                str += ' whichChoice="'+self.__whichChoice[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '</Switch>'
        return str


class TexCoordChaser2D(X3DChaserNode):
    def __init__(self, **kwargs):
        super(TexCoordChaser2D, self).__init__(**kwargs)
        duration  = kwargs.pop("duration", 1)
        if duration == None or duration  <  0:
            return None
        self.__duration = duration
        initialDestination  = kwargs.pop("initialDestination", None)
        self.__initialDestination = initialDestination
        initialValue  = kwargs.pop("initialValue", None)
        self.__initialValue = initialValue
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        destination  = kwargs.pop("destination", None)
        self.__destination = destination
        value  = kwargs.pop("value", None)
        self.__value = value
        value_changed  = kwargs.pop("value_changed", None)
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def isActive(self, Active = None):
        return self.__Active
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def destination(self):
        return self.__destination
    @destination.setter
    def destination(self, value = None):
        self.__destination = [value]
    def set_destination(self, destination = None):
        self.__destination = [destination]
        return self
    @property
    def value(self):
        return self.__value
    @value.setter
    def value(self, value = None):
        self.__value = [value]
    def set_value(self, value = None):
        self.__value = [value]
        return self
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<TexCoordChaser2D'
        if self.__duration is not None:
            if isinstance(self.__duration, six.string_types):
                str += ' duration="'+self.__duration+'"'
            else:
                str += ' duration="'+self.__duration[0]+'"'
        if self.__initialDestination is not None:
            if isinstance(self.__initialDestination, six.string_types):
                str += ' initialDestination="'+self.__initialDestination+'"'
            else:
                str += ' initialDestination="'+self.__initialDestination[0]+'"'
        if self.__initialValue is not None:
            if isinstance(self.__initialValue, six.string_types):
                str += ' initialValue="'+self.__initialValue+'"'
            else:
                str += ' initialValue="'+self.__initialValue[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__destination is not None:
            if isinstance(self.__destination, six.string_types):
                str += ' destination="'+self.__destination+'"'
            else:
                str += ' destination="'+self.__destination[0]+'"'
        if self.__value is not None:
            if isinstance(self.__value, six.string_types):
                str += ' value="'+self.__value+'"'
            else:
                str += ' value="'+self.__value[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</TexCoordChaser2D>'
        return str


class TexCoordDamper2D(X3DDamperNode):
    def __init__(self, **kwargs):
        super(TexCoordDamper2D, self).__init__(**kwargs)
        initialDestination  = kwargs.pop("initialDestination", None)
        self.__initialDestination = initialDestination
        initialValue  = kwargs.pop("initialValue", None)
        self.__initialValue = initialValue
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        order  = kwargs.pop("order", 3)
        if order == None or order  <  0:
            return None
        if order == None or order  >  5:
            return None
        self.__order = order
        destination  = kwargs.pop("destination", None)
        self.__destination = destination
        value  = kwargs.pop("value", None)
        self.__value = value
        tau  = kwargs.pop("tau", 0.3)
        if tau == None or tau  <  0:
            return None
        self.__tau = tau
        tolerance  = kwargs.pop("tolerance", -1)
        self.__tolerance = tolerance
        value_changed  = kwargs.pop("value_changed", None)
        self.__value_changed = value_changed
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def isActive(self, Active = None):
        return self.__Active
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def destination(self):
        return self.__destination
    @destination.setter
    def destination(self, value = None):
        self.__destination = [value]
    def set_destination(self, destination = None):
        self.__destination = [destination]
        return self
    @property
    def value(self):
        return self.__value
    @value.setter
    def value(self, value = None):
        self.__value = [value]
    def set_value(self, value = None):
        self.__value = [value]
        return self
    @property
    def tau(self):
        return self.__tau
    @tau.setter
    def tau(self, value = 0.3):
        if value == None or value  <  0:
            return None
        self.__tau = [value]
    def setTau(self, tau = 0.3):
        if tau == None or tau  <  0:
            return None
        self.__tau = [tau]
        return self
    def addTau(self, tau = 0.3):
        if tau == None or tau  <  0:
            return None
        if self.__tau == None:            self.__tau =  []
        self.__tau +=  [tau]
        return self
    def removeTau(self, tau):
        self.__tau = [x for x in self.__tau if x not in tau]
        return self.__tau
    def getTau(self, tau = 0.3):
        return self.__tau
    def tau_changed(self, tau = 0.3):
        return self.__tau
    @property
    def tolerance(self):
        return self.__tolerance
    @tolerance.setter
    def tolerance(self, value = -1):
        self.__tolerance = [value]
    def setTolerance(self, tolerance = -1):
        self.__tolerance = [tolerance]
        return self
    def addTolerance(self, tolerance = -1):
        if self.__tolerance == None:            self.__tolerance =  []
        self.__tolerance +=  [tolerance]
        return self
    def removeTolerance(self, tolerance):
        self.__tolerance = [x for x in self.__tolerance if x not in tolerance]
        return self.__tolerance
    def getTolerance(self, tolerance = -1):
        return self.__tolerance
    def tolerance_changed(self, tolerance = -1):
        return self.__tolerance
    def removevalue_changed(self, value_changed):
        self.__value_changed = [x for x in self.__value_changed if x not in value_changed]
        return self.__value_changed
    def getvalue_changed(self, value_changed = None):
        return self.__value_changed
    def value_changed_changed(self, value_changed = None):
        return self.__value_changed
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<TexCoordDamper2D'
        if self.__initialDestination is not None:
            if isinstance(self.__initialDestination, six.string_types):
                str += ' initialDestination="'+self.__initialDestination+'"'
            else:
                str += ' initialDestination="'+self.__initialDestination[0]+'"'
        if self.__initialValue is not None:
            if isinstance(self.__initialValue, six.string_types):
                str += ' initialValue="'+self.__initialValue+'"'
            else:
                str += ' initialValue="'+self.__initialValue[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__order is not None:
            if isinstance(self.__order, six.string_types):
                str += ' order="'+self.__order+'"'
            else:
                str += ' order="'+self.__order[0]+'"'
        if self.__destination is not None:
            if isinstance(self.__destination, six.string_types):
                str += ' destination="'+self.__destination+'"'
            else:
                str += ' destination="'+self.__destination[0]+'"'
        if self.__value is not None:
            if isinstance(self.__value, six.string_types):
                str += ' value="'+self.__value+'"'
            else:
                str += ' value="'+self.__value[0]+'"'
        if self.__tau is not None:
            if isinstance(self.__tau, six.string_types):
                str += ' tau="'+self.__tau+'"'
            else:
                str += ' tau="'+self.__tau[0]+'"'
        if self.__tolerance is not None:
            if isinstance(self.__tolerance, six.string_types):
                str += ' tolerance="'+self.__tolerance+'"'
            else:
                str += ' tolerance="'+self.__tolerance[0]+'"'
        if self.__value_changed is not None:
            if isinstance(self.__value_changed, six.string_types):
                str += ' value_changed="'+self.__value_changed+'"'
            else:
                str += ' value_changed="'+self.__value_changed[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</TexCoordDamper2D>'
        return str


class Text(X3DGeometryNode):
    def __init__(self, **kwargs):
        super(Text, self).__init__(**kwargs)
        fontStyle  = kwargs.pop("fontStyle", None)
        self.__fontStyle = fontStyle
        length  = kwargs.pop("length", None)
        if length == None or len(length) <= 0 or min(length)  <  0:
            return None
        self.__length = length
        lineBounds  = kwargs.pop("lineBounds", None)
        self.__lineBounds = lineBounds
        maxExtent  = kwargs.pop("maxExtent", 0.0)
        if maxExtent == None or maxExtent  <  0:
            return None
        self.__maxExtent = maxExtent
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        origin  = kwargs.pop("origin", None)
        self.__origin = origin
        solid  = kwargs.pop("solid", False)
        self.__solid = solid
        string  = kwargs.pop("string", None)
        self.__string = string
        textBounds  = kwargs.pop("textBounds", None)
        self.__textBounds = textBounds
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def fontStyle(self):
        return self.__fontStyle
    @fontStyle.setter
    def fontStyle(self, value = None):
        self.__fontStyle = [value]
    def setFontStyle(self, fontStyle = None):
        self.__fontStyle = [fontStyle]
        return self
    def addFontStyle(self, fontStyle = None):
        if self.__fontStyle == None:            self.__fontStyle =  []
        self.__fontStyle +=  [fontStyle]
        return self
    def removeFontStyle(self, fontStyle):
        self.__fontStyle = [x for x in self.__fontStyle if x not in fontStyle]
        return self.__fontStyle
    def getFontStyle(self, fontStyle = None):
        return self.__fontStyle
    def fontStyle_changed(self, fontStyle = None):
        return self.__fontStyle
    @property
    def length(self):
        return self.__length
    @length.setter
    def length(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        self.__length = [value]
    def setLength(self, length = None):
        if length == None or len(length) <= 0 or min(length)  <  0:
            return None
        self.__length = [length]
        return self
    def addLength(self, length = None):
        if length == None or len(length) <= 0 or min(length)  <  0:
            return None
        if self.__length == None:            self.__length =  []
        self.__length +=  [length]
        return self
    def removeLength(self, length):
        self.__length = [x for x in self.__length if x not in length]
        return self.__length
    def getLength(self, length = None):
        return self.__length
    def length_changed(self, length = None):
        return self.__length
    def removeLineBounds(self, lineBounds):
        self.__lineBounds = [x for x in self.__lineBounds if x not in lineBounds]
        return self.__lineBounds
    def getLineBounds(self, lineBounds = None):
        return self.__lineBounds
    def lineBounds_changed(self, lineBounds = None):
        return self.__lineBounds
    @property
    def maxExtent(self):
        return self.__maxExtent
    @maxExtent.setter
    def maxExtent(self, value = 0.0):
        if value == None or value  <  0:
            return None
        self.__maxExtent = [value]
    def setMaxExtent(self, maxExtent = 0.0):
        if maxExtent == None or maxExtent  <  0:
            return None
        self.__maxExtent = [maxExtent]
        return self
    def addMaxExtent(self, maxExtent = 0.0):
        if maxExtent == None or maxExtent  <  0:
            return None
        if self.__maxExtent == None:            self.__maxExtent =  []
        self.__maxExtent +=  [maxExtent]
        return self
    def removeMaxExtent(self, maxExtent):
        self.__maxExtent = [x for x in self.__maxExtent if x not in maxExtent]
        return self.__maxExtent
    def getMaxExtent(self, maxExtent = 0.0):
        return self.__maxExtent
    def maxExtent_changed(self, maxExtent = 0.0):
        return self.__maxExtent
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    def removeOrigin(self, origin):
        self.__origin = [x for x in self.__origin if x not in origin]
        return self.__origin
    def getOrigin(self, origin = None):
        return self.__origin
    def origin_changed(self, origin = None):
        return self.__origin
    @property
    def string(self):
        return self.__string
    @string.setter
    def string(self, value = None):
        self.__string = [value]
    def setString(self, string = None):
        self.__string = [string]
        return self
    def addString(self, string = None):
        if self.__string == None:            self.__string =  []
        self.__string +=  [string]
        return self
    def removeString(self, string):
        self.__string = [x for x in self.__string if x not in string]
        return self.__string
    def getString(self, string = None):
        return self.__string
    def string_changed(self, string = None):
        return self.__string
    def removeTextBounds(self, textBounds):
        self.__textBounds = [x for x in self.__textBounds if x not in textBounds]
        return self.__textBounds
    def getTextBounds(self, textBounds = None):
        return self.__textBounds
    def textBounds_changed(self, textBounds = None):
        return self.__textBounds
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Text'
        if self.__length is not None:
            if isinstance(self.__length, six.string_types):
                str += ' length="'+self.__length+'"'
            else:
                str += ' length="'+self.__length[0]+'"'
        if self.__lineBounds is not None:
            if isinstance(self.__lineBounds, six.string_types):
                str += ' lineBounds="'+self.__lineBounds+'"'
            else:
                str += ' lineBounds="'+self.__lineBounds[0]+'"'
        if self.__maxExtent is not None:
            if isinstance(self.__maxExtent, six.string_types):
                str += ' maxExtent="'+self.__maxExtent+'"'
            else:
                str += ' maxExtent="'+self.__maxExtent[0]+'"'
        if self.__origin is not None:
            if isinstance(self.__origin, six.string_types):
                str += ' origin="'+self.__origin+'"'
            else:
                str += ' origin="'+self.__origin[0]+'"'
        if self.__solid is not None:
            if isinstance(self.__solid, six.string_types):
                str += ' solid="'+self.__solid+'"'
            else:
                str += ' solid="'+self.__solid[0]+'"'
        if self.__string is not None:
            if isinstance(self.__string, six.string_types):
                str += ' string="'+self.__string+'"'
            else:
                str += ' string="'+self.__string[0]+'"'
        if self.__textBounds is not None:
            if isinstance(self.__textBounds, six.string_types):
                str += ' textBounds="'+self.__textBounds+'"'
            else:
                str += ' textBounds="'+self.__textBounds[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<fontStyle'
        if self.__fontStyle is not None:
           for s in self.__fontStyle:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__fontStyle is not None:
           for s in self.__fontStyle:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</fontStyle>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</Text>'
        return str


class TextureBackground(X3DBackgroundNode):
    def __init__(self, **kwargs):
        super(TextureBackground, self).__init__(**kwargs)
        backTexture  = kwargs.pop("backTexture", None)
        self.__backTexture = backTexture
        bindTime  = kwargs.pop("bindTime", None)
        self.__bindTime = bindTime
        bottomTexture  = kwargs.pop("bottomTexture", None)
        self.__bottomTexture = bottomTexture
        frontTexture  = kwargs.pop("frontTexture", None)
        self.__frontTexture = frontTexture
        groundAngle  = kwargs.pop("groundAngle", None)
        if groundAngle == None or len(groundAngle) <= 0 or min(groundAngle)  <  0:
            return None
        if groundAngle == None or len(groundAngle) <= 0 or max(groundAngle)  >  1.5708:
            return None
        self.__groundAngle = groundAngle
        groundColor  = kwargs.pop("groundColor", None)
        if groundColor == None or len(groundColor) <= 0 or min(groundColor)  <  0:
            return None
        if groundColor == None or len(groundColor) <= 0 or max(groundColor)  >  1:
            return None
        self.__groundColor = groundColor
        Bound  = kwargs.pop("Bound", None)
        self.__Bound = Bound
        leftTexture  = kwargs.pop("leftTexture", None)
        self.__leftTexture = leftTexture
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        rightTexture  = kwargs.pop("rightTexture", None)
        self.__rightTexture = rightTexture
        bind  = kwargs.pop("bind", None)
        self.__bind = bind
        skyAngle  = kwargs.pop("skyAngle", None)
        if skyAngle == None or len(skyAngle) <= 0 or min(skyAngle)  <  0:
            return None
        if skyAngle == None or len(skyAngle) <= 0 or max(skyAngle)  >  3.1416:
            return None
        self.__skyAngle = skyAngle
        skyColor  = kwargs.pop("skyColor", [0, 0, 0])
        if skyColor == None or len(skyColor) <= 0 or min(skyColor)  <  0:
            return None
        if skyColor == None or len(skyColor) <= 0 or max(skyColor)  >  1:
            return None
        self.__skyColor = skyColor
        topTexture  = kwargs.pop("topTexture", None)
        self.__topTexture = topTexture
        transparency  = kwargs.pop("transparency", 0)
        if transparency == None or transparency  <  0:
            return None
        if transparency == None or transparency  >  1:
            return None
        self.__transparency = transparency
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def backTexture(self):
        return self.__backTexture
    @backTexture.setter
    def backTexture(self, value = None):
        self.__backTexture = [value]
    def setBackTexture(self, backTexture = None):
        self.__backTexture = [backTexture]
        return self
    def addBackTexture(self, backTexture = None):
        if self.__backTexture == None:            self.__backTexture =  []
        self.__backTexture +=  [backTexture]
        return self
    def removeBackTexture(self, backTexture):
        self.__backTexture = [x for x in self.__backTexture if x not in backTexture]
        return self.__backTexture
    def getBackTexture(self, backTexture = None):
        return self.__backTexture
    def backTexture_changed(self, backTexture = None):
        return self.__backTexture
    def removeBindTime(self, bindTime):
        self.__bindTime = [x for x in self.__bindTime if x not in bindTime]
        return self.__bindTime
    def getBindTime(self, bindTime = None):
        return self.__bindTime
    def bindTime_changed(self, bindTime = None):
        return self.__bindTime
    @property
    def bottomTexture(self):
        return self.__bottomTexture
    @bottomTexture.setter
    def bottomTexture(self, value = None):
        self.__bottomTexture = [value]
    def setBottomTexture(self, bottomTexture = None):
        self.__bottomTexture = [bottomTexture]
        return self
    def addBottomTexture(self, bottomTexture = None):
        if self.__bottomTexture == None:            self.__bottomTexture =  []
        self.__bottomTexture +=  [bottomTexture]
        return self
    def removeBottomTexture(self, bottomTexture):
        self.__bottomTexture = [x for x in self.__bottomTexture if x not in bottomTexture]
        return self.__bottomTexture
    def getBottomTexture(self, bottomTexture = None):
        return self.__bottomTexture
    def bottomTexture_changed(self, bottomTexture = None):
        return self.__bottomTexture
    @property
    def frontTexture(self):
        return self.__frontTexture
    @frontTexture.setter
    def frontTexture(self, value = None):
        self.__frontTexture = [value]
    def setFrontTexture(self, frontTexture = None):
        self.__frontTexture = [frontTexture]
        return self
    def addFrontTexture(self, frontTexture = None):
        if self.__frontTexture == None:            self.__frontTexture =  []
        self.__frontTexture +=  [frontTexture]
        return self
    def removeFrontTexture(self, frontTexture):
        self.__frontTexture = [x for x in self.__frontTexture if x not in frontTexture]
        return self.__frontTexture
    def getFrontTexture(self, frontTexture = None):
        return self.__frontTexture
    def frontTexture_changed(self, frontTexture = None):
        return self.__frontTexture
    @property
    def groundAngle(self):
        return self.__groundAngle
    @groundAngle.setter
    def groundAngle(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1.5708:
            return None
        self.__groundAngle = [value]
    def setGroundAngle(self, groundAngle = None):
        if groundAngle == None or len(groundAngle) <= 0 or min(groundAngle)  <  0:
            return None
        if groundAngle == None or len(groundAngle) <= 0 or max(groundAngle)  >  1.5708:
            return None
        self.__groundAngle = [groundAngle]
        return self
    def addGroundAngle(self, groundAngle = None):
        if groundAngle == None or len(groundAngle) <= 0 or min(groundAngle)  <  0:
            return None
        if groundAngle == None or len(groundAngle) <= 0 or max(groundAngle)  >  1.5708:
            return None
        if self.__groundAngle == None:            self.__groundAngle =  []
        self.__groundAngle +=  [groundAngle]
        return self
    def removeGroundAngle(self, groundAngle):
        self.__groundAngle = [x for x in self.__groundAngle if x not in groundAngle]
        return self.__groundAngle
    def getGroundAngle(self, groundAngle = None):
        return self.__groundAngle
    def groundAngle_changed(self, groundAngle = None):
        return self.__groundAngle
    @property
    def groundColor(self):
        return self.__groundColor
    @groundColor.setter
    def groundColor(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__groundColor = [value]
    def setGroundColor(self, groundColor = None):
        if groundColor == None or len(groundColor) <= 0 or min(groundColor)  <  0:
            return None
        if groundColor == None or len(groundColor) <= 0 or max(groundColor)  >  1:
            return None
        self.__groundColor = [groundColor]
        return self
    def addGroundColor(self, groundColor = None):
        if groundColor == None or len(groundColor) <= 0 or min(groundColor)  <  0:
            return None
        if groundColor == None or len(groundColor) <= 0 or max(groundColor)  >  1:
            return None
        if self.__groundColor == None:            self.__groundColor =  []
        self.__groundColor +=  [groundColor]
        return self
    def removeGroundColor(self, groundColor):
        self.__groundColor = [x for x in self.__groundColor if x not in groundColor]
        return self.__groundColor
    def getGroundColor(self, groundColor = None):
        return self.__groundColor
    def groundColor_changed(self, groundColor = None):
        return self.__groundColor
    def isBound(self, Bound = None):
        return self.__Bound
    @property
    def leftTexture(self):
        return self.__leftTexture
    @leftTexture.setter
    def leftTexture(self, value = None):
        self.__leftTexture = [value]
    def setLeftTexture(self, leftTexture = None):
        self.__leftTexture = [leftTexture]
        return self
    def addLeftTexture(self, leftTexture = None):
        if self.__leftTexture == None:            self.__leftTexture =  []
        self.__leftTexture +=  [leftTexture]
        return self
    def removeLeftTexture(self, leftTexture):
        self.__leftTexture = [x for x in self.__leftTexture if x not in leftTexture]
        return self.__leftTexture
    def getLeftTexture(self, leftTexture = None):
        return self.__leftTexture
    def leftTexture_changed(self, leftTexture = None):
        return self.__leftTexture
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def rightTexture(self):
        return self.__rightTexture
    @rightTexture.setter
    def rightTexture(self, value = None):
        self.__rightTexture = [value]
    def setRightTexture(self, rightTexture = None):
        self.__rightTexture = [rightTexture]
        return self
    def addRightTexture(self, rightTexture = None):
        if self.__rightTexture == None:            self.__rightTexture =  []
        self.__rightTexture +=  [rightTexture]
        return self
    def removeRightTexture(self, rightTexture):
        self.__rightTexture = [x for x in self.__rightTexture if x not in rightTexture]
        return self.__rightTexture
    def getRightTexture(self, rightTexture = None):
        return self.__rightTexture
    def rightTexture_changed(self, rightTexture = None):
        return self.__rightTexture
    @property
    def bind(self):
        return self.__bind
    @bind.setter
    def bind(self, value = None):
        self.__bind = [value]
    def set_bind(self, bind = None):
        self.__bind = [bind]
        return self
    @property
    def skyAngle(self):
        return self.__skyAngle
    @skyAngle.setter
    def skyAngle(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  3.1416:
            return None
        self.__skyAngle = [value]
    def setSkyAngle(self, skyAngle = None):
        if skyAngle == None or len(skyAngle) <= 0 or min(skyAngle)  <  0:
            return None
        if skyAngle == None or len(skyAngle) <= 0 or max(skyAngle)  >  3.1416:
            return None
        self.__skyAngle = [skyAngle]
        return self
    def addSkyAngle(self, skyAngle = None):
        if skyAngle == None or len(skyAngle) <= 0 or min(skyAngle)  <  0:
            return None
        if skyAngle == None or len(skyAngle) <= 0 or max(skyAngle)  >  3.1416:
            return None
        if self.__skyAngle == None:            self.__skyAngle =  []
        self.__skyAngle +=  [skyAngle]
        return self
    def removeSkyAngle(self, skyAngle):
        self.__skyAngle = [x for x in self.__skyAngle if x not in skyAngle]
        return self.__skyAngle
    def getSkyAngle(self, skyAngle = None):
        return self.__skyAngle
    def skyAngle_changed(self, skyAngle = None):
        return self.__skyAngle
    @property
    def skyColor(self):
        return self.__skyColor
    @skyColor.setter
    def skyColor(self, value = [0, 0, 0]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__skyColor = [value]
    def setSkyColor(self, skyColor = [0, 0, 0]):
        if skyColor == None or len(skyColor) <= 0 or min(skyColor)  <  0:
            return None
        if skyColor == None or len(skyColor) <= 0 or max(skyColor)  >  1:
            return None
        self.__skyColor = [skyColor]
        return self
    def addSkyColor(self, skyColor = [0, 0, 0]):
        if skyColor == None or len(skyColor) <= 0 or min(skyColor)  <  0:
            return None
        if skyColor == None or len(skyColor) <= 0 or max(skyColor)  >  1:
            return None
        if self.__skyColor == None:            self.__skyColor =  []
        self.__skyColor +=  [skyColor]
        return self
    def removeSkyColor(self, skyColor):
        self.__skyColor = [x for x in self.__skyColor if x not in skyColor]
        return self.__skyColor
    def getSkyColor(self, skyColor = [0, 0, 0]):
        return self.__skyColor
    def skyColor_changed(self, skyColor = [0, 0, 0]):
        return self.__skyColor
    @property
    def topTexture(self):
        return self.__topTexture
    @topTexture.setter
    def topTexture(self, value = None):
        self.__topTexture = [value]
    def setTopTexture(self, topTexture = None):
        self.__topTexture = [topTexture]
        return self
    def addTopTexture(self, topTexture = None):
        if self.__topTexture == None:            self.__topTexture =  []
        self.__topTexture +=  [topTexture]
        return self
    def removeTopTexture(self, topTexture):
        self.__topTexture = [x for x in self.__topTexture if x not in topTexture]
        return self.__topTexture
    def getTopTexture(self, topTexture = None):
        return self.__topTexture
    def topTexture_changed(self, topTexture = None):
        return self.__topTexture
    @property
    def transparency(self):
        return self.__transparency
    @transparency.setter
    def transparency(self, value = 0):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__transparency = [value]
    def setTransparency(self, transparency = 0):
        if transparency == None or transparency  <  0:
            return None
        if transparency == None or transparency  >  1:
            return None
        self.__transparency = [transparency]
        return self
    def addTransparency(self, transparency = 0):
        if transparency == None or transparency  <  0:
            return None
        if transparency == None or transparency  >  1:
            return None
        if self.__transparency == None:            self.__transparency =  []
        self.__transparency +=  [transparency]
        return self
    def removeTransparency(self, transparency):
        self.__transparency = [x for x in self.__transparency if x not in transparency]
        return self.__transparency
    def getTransparency(self, transparency = 0):
        return self.__transparency
    def transparency_changed(self, transparency = 0):
        return self.__transparency
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<TextureBackground'
        if self.__bindTime is not None:
            if isinstance(self.__bindTime, six.string_types):
                str += ' bindTime="'+self.__bindTime+'"'
            else:
                str += ' bindTime="'+self.__bindTime[0]+'"'
        if self.__groundAngle is not None:
            if isinstance(self.__groundAngle, six.string_types):
                str += ' groundAngle="'+self.__groundAngle+'"'
            else:
                str += ' groundAngle="'+self.__groundAngle[0]+'"'
        if self.__groundColor is not None:
            if isinstance(self.__groundColor, six.string_types):
                str += ' groundColor="'+self.__groundColor+'"'
            else:
                str += ' groundColor="'+self.__groundColor[0]+'"'
        if self.__Bound is not None:
            if isinstance(self.__Bound, six.string_types):
                str += ' Bound="'+self.__Bound+'"'
            else:
                str += ' Bound="'+self.__Bound[0]+'"'
        if self.__bind is not None:
            if isinstance(self.__bind, six.string_types):
                str += ' bind="'+self.__bind+'"'
            else:
                str += ' bind="'+self.__bind[0]+'"'
        if self.__skyAngle is not None:
            if isinstance(self.__skyAngle, six.string_types):
                str += ' skyAngle="'+self.__skyAngle+'"'
            else:
                str += ' skyAngle="'+self.__skyAngle[0]+'"'
        if self.__skyColor is not None:
            if isinstance(self.__skyColor, six.string_types):
                str += ' skyColor="'+self.__skyColor+'"'
            else:
                str += ' skyColor="'+self.__skyColor[0]+'"'
        if self.__transparency is not None:
            if isinstance(self.__transparency, six.string_types):
                str += ' transparency="'+self.__transparency+'"'
            else:
                str += ' transparency="'+self.__transparency[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<backTexture'
        if self.__backTexture is not None:
           for s in self.__backTexture:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__backTexture is not None:
           for s in self.__backTexture:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</backTexture>'
        str += '<bottomTexture'
        if self.__bottomTexture is not None:
           for s in self.__bottomTexture:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__bottomTexture is not None:
           for s in self.__bottomTexture:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</bottomTexture>'
        str += '<frontTexture'
        if self.__frontTexture is not None:
           for s in self.__frontTexture:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__frontTexture is not None:
           for s in self.__frontTexture:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</frontTexture>'
        str += '<leftTexture'
        if self.__leftTexture is not None:
           for s in self.__leftTexture:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__leftTexture is not None:
           for s in self.__leftTexture:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</leftTexture>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<rightTexture'
        if self.__rightTexture is not None:
           for s in self.__rightTexture:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__rightTexture is not None:
           for s in self.__rightTexture:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</rightTexture>'
        str += '<topTexture'
        if self.__topTexture is not None:
           for s in self.__topTexture:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__topTexture is not None:
           for s in self.__topTexture:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</topTexture>'
        str += '</TextureBackground>'
        return str


class TextureCoordinate(X3DTextureCoordinateNode):
    def __init__(self, **kwargs):
        super(TextureCoordinate, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        point  = kwargs.pop("point", None)
        self.__point = point
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def point(self):
        return self.__point
    @point.setter
    def point(self, value = None):
        self.__point = [value]
    def setPoint(self, point = None):
        self.__point = [point]
        return self
    def addPoint(self, point = None):
        if self.__point == None:            self.__point =  []
        self.__point +=  [point]
        return self
    def removePoint(self, point):
        self.__point = [x for x in self.__point if x not in point]
        return self.__point
    def getPoint(self, point = None):
        return self.__point
    def point_changed(self, point = None):
        return self.__point
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<TextureCoordinate'
        if self.__point is not None:
            if isinstance(self.__point, six.string_types):
                str += ' point="'+self.__point+'"'
            else:
                str += ' point="'+self.__point[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</TextureCoordinate>'
        return str


class TextureCoordinate3D(X3DTextureCoordinateNode):
    def __init__(self, **kwargs):
        super(TextureCoordinate3D, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        point  = kwargs.pop("point", None)
        self.__point = point
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def point(self):
        return self.__point
    @point.setter
    def point(self, value = None):
        self.__point = [value]
    def setPoint(self, point = None):
        self.__point = [point]
        return self
    def addPoint(self, point = None):
        if self.__point == None:            self.__point =  []
        self.__point +=  [point]
        return self
    def removePoint(self, point):
        self.__point = [x for x in self.__point if x not in point]
        return self.__point
    def getPoint(self, point = None):
        return self.__point
    def point_changed(self, point = None):
        return self.__point
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<TextureCoordinate3D'
        if self.__point is not None:
            if isinstance(self.__point, six.string_types):
                str += ' point="'+self.__point+'"'
            else:
                str += ' point="'+self.__point[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</TextureCoordinate3D>'
        return str


class TextureCoordinate4D(X3DTextureCoordinateNode):
    def __init__(self, **kwargs):
        super(TextureCoordinate4D, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        point  = kwargs.pop("point", None)
        self.__point = point
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def point(self):
        return self.__point
    @point.setter
    def point(self, value = None):
        self.__point = [value]
    def setPoint(self, point = None):
        self.__point = [point]
        return self
    def addPoint(self, point = None):
        if self.__point == None:            self.__point =  []
        self.__point +=  [point]
        return self
    def removePoint(self, point):
        self.__point = [x for x in self.__point if x not in point]
        return self.__point
    def getPoint(self, point = None):
        return self.__point
    def point_changed(self, point = None):
        return self.__point
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<TextureCoordinate4D'
        if self.__point is not None:
            if isinstance(self.__point, six.string_types):
                str += ' point="'+self.__point+'"'
            else:
                str += ' point="'+self.__point[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</TextureCoordinate4D>'
        return str


class TextureCoordinateGenerator(X3DTextureCoordinateNode):
    def __init__(self, **kwargs):
        super(TextureCoordinateGenerator, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        mode  = kwargs.pop("mode", "SPHERE")
        if 'SPHERE' == mode:
            pass
        elif 'CAMERASPACENORMAL' == mode:
            pass
        elif 'CAMERASPACEPOSITION' == mode:
            pass
        elif 'CAMERASPACEREFLECTIONVECTOR' == mode:
            pass
        elif 'SPHERE-LOCAL' == mode:
            pass
        elif 'COORD' == mode:
            pass
        elif 'COORD-EYE' == mode:
            pass
        elif 'NOISE' == mode:
            pass
        elif 'NOISE-EYE' == mode:
            pass
        elif 'SPHERE-REFLECT' == mode:
            pass
        elif 'SPHERE-REFLECT-LOCAL' == mode:
            pass
        else:
            return None
        self.__mode = mode
        parameter  = kwargs.pop("parameter", None)
        self.__parameter = parameter
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def mode(self):
        return self.__mode
    @mode.setter
    def mode(self, value = "SPHERE"):
        if 'SPHERE' == value:
            pass
        elif 'CAMERASPACENORMAL' == value:
            pass
        elif 'CAMERASPACEPOSITION' == value:
            pass
        elif 'CAMERASPACEREFLECTIONVECTOR' == value:
            pass
        elif 'SPHERE-LOCAL' == value:
            pass
        elif 'COORD' == value:
            pass
        elif 'COORD-EYE' == value:
            pass
        elif 'NOISE' == value:
            pass
        elif 'NOISE-EYE' == value:
            pass
        elif 'SPHERE-REFLECT' == value:
            pass
        elif 'SPHERE-REFLECT-LOCAL' == value:
            pass
        else:
            return None
        self.__mode = [value]
    def setMode(self, mode = "SPHERE"):
        if 'SPHERE' == mode:
            pass
        elif 'CAMERASPACENORMAL' == mode:
            pass
        elif 'CAMERASPACEPOSITION' == mode:
            pass
        elif 'CAMERASPACEREFLECTIONVECTOR' == mode:
            pass
        elif 'SPHERE-LOCAL' == mode:
            pass
        elif 'COORD' == mode:
            pass
        elif 'COORD-EYE' == mode:
            pass
        elif 'NOISE' == mode:
            pass
        elif 'NOISE-EYE' == mode:
            pass
        elif 'SPHERE-REFLECT' == mode:
            pass
        elif 'SPHERE-REFLECT-LOCAL' == mode:
            pass
        else:
            return None
        self.__mode = [mode]
        return self
    def addMode(self, mode = "SPHERE"):
        if 'SPHERE' == mode:
            pass
        elif 'CAMERASPACENORMAL' == mode:
            pass
        elif 'CAMERASPACEPOSITION' == mode:
            pass
        elif 'CAMERASPACEREFLECTIONVECTOR' == mode:
            pass
        elif 'SPHERE-LOCAL' == mode:
            pass
        elif 'COORD' == mode:
            pass
        elif 'COORD-EYE' == mode:
            pass
        elif 'NOISE' == mode:
            pass
        elif 'NOISE-EYE' == mode:
            pass
        elif 'SPHERE-REFLECT' == mode:
            pass
        elif 'SPHERE-REFLECT-LOCAL' == mode:
            pass
        else:
            return None
        if self.__mode == None:            self.__mode =  []
        self.__mode +=  [mode]
        return self
    def removeMode(self, mode):
        self.__mode = [x for x in self.__mode if x not in mode]
        return self.__mode
    def getMode(self, mode = "SPHERE"):
        return self.__mode
    def mode_changed(self, mode = "SPHERE"):
        return self.__mode
    @property
    def parameter(self):
        return self.__parameter
    @parameter.setter
    def parameter(self, value = None):
        self.__parameter = [value]
    def setParameter(self, parameter = None):
        self.__parameter = [parameter]
        return self
    def addParameter(self, parameter = None):
        if self.__parameter == None:            self.__parameter =  []
        self.__parameter +=  [parameter]
        return self
    def removeParameter(self, parameter):
        self.__parameter = [x for x in self.__parameter if x not in parameter]
        return self.__parameter
    def getParameter(self, parameter = None):
        return self.__parameter
    def parameter_changed(self, parameter = None):
        return self.__parameter
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<TextureCoordinateGenerator'
        if self.__mode is not None:
            if isinstance(self.__mode, six.string_types):
                str += ' mode="'+self.__mode+'"'
            else:
                str += ' mode="'+self.__mode[0]+'"'
        if self.__parameter is not None:
            if isinstance(self.__parameter, six.string_types):
                str += ' parameter="'+self.__parameter+'"'
            else:
                str += ' parameter="'+self.__parameter[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</TextureCoordinateGenerator>'
        return str


class TextureProperties(X3DNode):
    def __init__(self, **kwargs):
        super(TextureProperties, self).__init__(**kwargs)
        anisotropicDegree  = kwargs.pop("anisotropicDegree", 1)
        if anisotropicDegree == None or anisotropicDegree  <  1:
            return None
        self.__anisotropicDegree = anisotropicDegree
        borderColor  = kwargs.pop("borderColor", [0, 0, 0, 0])
        if borderColor == None or borderColor  <  0:
            return None
        if borderColor == None or borderColor  >  1:
            return None
        self.__borderColor = borderColor
        borderWidth  = kwargs.pop("borderWidth", 0)
        if borderWidth == None or borderWidth  <  0:
            return None
        self.__borderWidth = borderWidth
        boundaryModeR  = kwargs.pop("boundaryModeR", "REPEAT")
        if 'CLAMP' == boundaryModeR:
            pass
        elif 'CLAMP_TO_EDGE' == boundaryModeR:
            pass
        elif 'CLAMP_TO_BOUNDARY' == boundaryModeR:
            pass
        elif 'MIRRORED_REPEAT' == boundaryModeR:
            pass
        elif 'REPEAT' == boundaryModeR:
            pass
        else:
            return None
        self.__boundaryModeR = boundaryModeR
        boundaryModeS  = kwargs.pop("boundaryModeS", "REPEAT")
        if 'CLAMP' == boundaryModeS:
            pass
        elif 'CLAMP_TO_EDGE' == boundaryModeS:
            pass
        elif 'CLAMP_TO_BOUNDARY' == boundaryModeS:
            pass
        elif 'MIRRORED_REPEAT' == boundaryModeS:
            pass
        elif 'REPEAT' == boundaryModeS:
            pass
        else:
            return None
        self.__boundaryModeS = boundaryModeS
        boundaryModeT  = kwargs.pop("boundaryModeT", "REPEAT")
        if 'CLAMP' == boundaryModeT:
            pass
        elif 'CLAMP_TO_EDGE' == boundaryModeT:
            pass
        elif 'CLAMP_TO_BOUNDARY' == boundaryModeT:
            pass
        elif 'MIRRORED_REPEAT' == boundaryModeT:
            pass
        elif 'REPEAT' == boundaryModeT:
            pass
        else:
            return None
        self.__boundaryModeT = boundaryModeT
        generateMipMaps  = kwargs.pop("generateMipMaps", False)
        self.__generateMipMaps = generateMipMaps
        magnificationFilter  = kwargs.pop("magnificationFilter", "FASTEST")
        if 'AVG_PIXEL' == magnificationFilter:
            pass
        elif 'DEFAULT' == magnificationFilter:
            pass
        elif 'FASTEST' == magnificationFilter:
            pass
        elif 'NEAREST_PIXEL' == magnificationFilter:
            pass
        elif 'NICEST' == magnificationFilter:
            pass
        else:
            return None
        self.__magnificationFilter = magnificationFilter
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        minificationFilter  = kwargs.pop("minificationFilter", "FASTEST")
        if 'AVG_PIXEL' == minificationFilter:
            pass
        elif 'AVG_PIXEL_AVG_MIPMAP' == minificationFilter:
            pass
        elif 'AVG_PIXEL_NEAREST_MIPMAP' == minificationFilter:
            pass
        elif 'DEFAULT' == minificationFilter:
            pass
        elif 'FASTEST' == minificationFilter:
            pass
        elif 'NEAREST_PIXEL' == minificationFilter:
            pass
        elif 'NEAREST_PIXEL_AVG_MIPMAP' == minificationFilter:
            pass
        elif 'NEAREST_PIXEL_NEAREST_MIPMAP' == minificationFilter:
            pass
        elif 'NICEST' == minificationFilter:
            pass
        else:
            return None
        self.__minificationFilter = minificationFilter
        textureCompression  = kwargs.pop("textureCompression", "FASTEST")
        if 'DEFAULT' == textureCompression:
            pass
        elif 'FASTEST' == textureCompression:
            pass
        elif 'HIGH' == textureCompression:
            pass
        elif 'LOW' == textureCompression:
            pass
        elif 'MEDIUM' == textureCompression:
            pass
        elif 'NICEST' == textureCompression:
            pass
        else:
            return None
        self.__textureCompression = textureCompression
        texturePriority  = kwargs.pop("texturePriority", 0)
        if texturePriority == None or texturePriority  <  0:
            return None
        if texturePriority == None or texturePriority  >  1:
            return None
        self.__texturePriority = texturePriority
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def anisotropicDegree(self):
        return self.__anisotropicDegree
    @anisotropicDegree.setter
    def anisotropicDegree(self, value = 1):
        if value == None or value  <  1:
            return None
        self.__anisotropicDegree = [value]
    def setAnisotropicDegree(self, anisotropicDegree = 1):
        if anisotropicDegree == None or anisotropicDegree  <  1:
            return None
        self.__anisotropicDegree = [anisotropicDegree]
        return self
    def addAnisotropicDegree(self, anisotropicDegree = 1):
        if anisotropicDegree == None or anisotropicDegree  <  1:
            return None
        if self.__anisotropicDegree == None:            self.__anisotropicDegree =  []
        self.__anisotropicDegree +=  [anisotropicDegree]
        return self
    def removeAnisotropicDegree(self, anisotropicDegree):
        self.__anisotropicDegree = [x for x in self.__anisotropicDegree if x not in anisotropicDegree]
        return self.__anisotropicDegree
    def getAnisotropicDegree(self, anisotropicDegree = 1):
        return self.__anisotropicDegree
    def anisotropicDegree_changed(self, anisotropicDegree = 1):
        return self.__anisotropicDegree
    @property
    def borderColor(self):
        return self.__borderColor
    @borderColor.setter
    def borderColor(self, value = [0, 0, 0, 0]):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__borderColor = [value]
    def setBorderColor(self, borderColor = [0, 0, 0, 0]):
        if borderColor == None or borderColor  <  0:
            return None
        if borderColor == None or borderColor  >  1:
            return None
        self.__borderColor = [borderColor]
        return self
    def addBorderColor(self, borderColor = [0, 0, 0, 0]):
        if borderColor == None or borderColor  <  0:
            return None
        if borderColor == None or borderColor  >  1:
            return None
        if self.__borderColor == None:            self.__borderColor =  []
        self.__borderColor +=  [borderColor]
        return self
    def removeBorderColor(self, borderColor):
        self.__borderColor = [x for x in self.__borderColor if x not in borderColor]
        return self.__borderColor
    def getBorderColor(self, borderColor = [0, 0, 0, 0]):
        return self.__borderColor
    def borderColor_changed(self, borderColor = [0, 0, 0, 0]):
        return self.__borderColor
    @property
    def borderWidth(self):
        return self.__borderWidth
    @borderWidth.setter
    def borderWidth(self, value = 0):
        if value == None or value  <  0:
            return None
        self.__borderWidth = [value]
    def setBorderWidth(self, borderWidth = 0):
        if borderWidth == None or borderWidth  <  0:
            return None
        self.__borderWidth = [borderWidth]
        return self
    def addBorderWidth(self, borderWidth = 0):
        if borderWidth == None or borderWidth  <  0:
            return None
        if self.__borderWidth == None:            self.__borderWidth =  []
        self.__borderWidth +=  [borderWidth]
        return self
    def removeBorderWidth(self, borderWidth):
        self.__borderWidth = [x for x in self.__borderWidth if x not in borderWidth]
        return self.__borderWidth
    def getBorderWidth(self, borderWidth = 0):
        return self.__borderWidth
    def borderWidth_changed(self, borderWidth = 0):
        return self.__borderWidth
    @property
    def boundaryModeR(self):
        return self.__boundaryModeR
    @boundaryModeR.setter
    def boundaryModeR(self, value = "REPEAT"):
        if 'CLAMP' == value:
            pass
        elif 'CLAMP_TO_EDGE' == value:
            pass
        elif 'CLAMP_TO_BOUNDARY' == value:
            pass
        elif 'MIRRORED_REPEAT' == value:
            pass
        elif 'REPEAT' == value:
            pass
        else:
            return None
        self.__boundaryModeR = [value]
    def setBoundaryModeR(self, boundaryModeR = "REPEAT"):
        if 'CLAMP' == boundaryModeR:
            pass
        elif 'CLAMP_TO_EDGE' == boundaryModeR:
            pass
        elif 'CLAMP_TO_BOUNDARY' == boundaryModeR:
            pass
        elif 'MIRRORED_REPEAT' == boundaryModeR:
            pass
        elif 'REPEAT' == boundaryModeR:
            pass
        else:
            return None
        self.__boundaryModeR = [boundaryModeR]
        return self
    def addBoundaryModeR(self, boundaryModeR = "REPEAT"):
        if 'CLAMP' == boundaryModeR:
            pass
        elif 'CLAMP_TO_EDGE' == boundaryModeR:
            pass
        elif 'CLAMP_TO_BOUNDARY' == boundaryModeR:
            pass
        elif 'MIRRORED_REPEAT' == boundaryModeR:
            pass
        elif 'REPEAT' == boundaryModeR:
            pass
        else:
            return None
        if self.__boundaryModeR == None:            self.__boundaryModeR =  []
        self.__boundaryModeR +=  [boundaryModeR]
        return self
    def removeBoundaryModeR(self, boundaryModeR):
        self.__boundaryModeR = [x for x in self.__boundaryModeR if x not in boundaryModeR]
        return self.__boundaryModeR
    def getBoundaryModeR(self, boundaryModeR = "REPEAT"):
        return self.__boundaryModeR
    def boundaryModeR_changed(self, boundaryModeR = "REPEAT"):
        return self.__boundaryModeR
    @property
    def boundaryModeS(self):
        return self.__boundaryModeS
    @boundaryModeS.setter
    def boundaryModeS(self, value = "REPEAT"):
        if 'CLAMP' == value:
            pass
        elif 'CLAMP_TO_EDGE' == value:
            pass
        elif 'CLAMP_TO_BOUNDARY' == value:
            pass
        elif 'MIRRORED_REPEAT' == value:
            pass
        elif 'REPEAT' == value:
            pass
        else:
            return None
        self.__boundaryModeS = [value]
    def setBoundaryModeS(self, boundaryModeS = "REPEAT"):
        if 'CLAMP' == boundaryModeS:
            pass
        elif 'CLAMP_TO_EDGE' == boundaryModeS:
            pass
        elif 'CLAMP_TO_BOUNDARY' == boundaryModeS:
            pass
        elif 'MIRRORED_REPEAT' == boundaryModeS:
            pass
        elif 'REPEAT' == boundaryModeS:
            pass
        else:
            return None
        self.__boundaryModeS = [boundaryModeS]
        return self
    def addBoundaryModeS(self, boundaryModeS = "REPEAT"):
        if 'CLAMP' == boundaryModeS:
            pass
        elif 'CLAMP_TO_EDGE' == boundaryModeS:
            pass
        elif 'CLAMP_TO_BOUNDARY' == boundaryModeS:
            pass
        elif 'MIRRORED_REPEAT' == boundaryModeS:
            pass
        elif 'REPEAT' == boundaryModeS:
            pass
        else:
            return None
        if self.__boundaryModeS == None:            self.__boundaryModeS =  []
        self.__boundaryModeS +=  [boundaryModeS]
        return self
    def removeBoundaryModeS(self, boundaryModeS):
        self.__boundaryModeS = [x for x in self.__boundaryModeS if x not in boundaryModeS]
        return self.__boundaryModeS
    def getBoundaryModeS(self, boundaryModeS = "REPEAT"):
        return self.__boundaryModeS
    def boundaryModeS_changed(self, boundaryModeS = "REPEAT"):
        return self.__boundaryModeS
    @property
    def boundaryModeT(self):
        return self.__boundaryModeT
    @boundaryModeT.setter
    def boundaryModeT(self, value = "REPEAT"):
        if 'CLAMP' == value:
            pass
        elif 'CLAMP_TO_EDGE' == value:
            pass
        elif 'CLAMP_TO_BOUNDARY' == value:
            pass
        elif 'MIRRORED_REPEAT' == value:
            pass
        elif 'REPEAT' == value:
            pass
        else:
            return None
        self.__boundaryModeT = [value]
    def setBoundaryModeT(self, boundaryModeT = "REPEAT"):
        if 'CLAMP' == boundaryModeT:
            pass
        elif 'CLAMP_TO_EDGE' == boundaryModeT:
            pass
        elif 'CLAMP_TO_BOUNDARY' == boundaryModeT:
            pass
        elif 'MIRRORED_REPEAT' == boundaryModeT:
            pass
        elif 'REPEAT' == boundaryModeT:
            pass
        else:
            return None
        self.__boundaryModeT = [boundaryModeT]
        return self
    def addBoundaryModeT(self, boundaryModeT = "REPEAT"):
        if 'CLAMP' == boundaryModeT:
            pass
        elif 'CLAMP_TO_EDGE' == boundaryModeT:
            pass
        elif 'CLAMP_TO_BOUNDARY' == boundaryModeT:
            pass
        elif 'MIRRORED_REPEAT' == boundaryModeT:
            pass
        elif 'REPEAT' == boundaryModeT:
            pass
        else:
            return None
        if self.__boundaryModeT == None:            self.__boundaryModeT =  []
        self.__boundaryModeT +=  [boundaryModeT]
        return self
    def removeBoundaryModeT(self, boundaryModeT):
        self.__boundaryModeT = [x for x in self.__boundaryModeT if x not in boundaryModeT]
        return self.__boundaryModeT
    def getBoundaryModeT(self, boundaryModeT = "REPEAT"):
        return self.__boundaryModeT
    def boundaryModeT_changed(self, boundaryModeT = "REPEAT"):
        return self.__boundaryModeT
    @property
    def magnificationFilter(self):
        return self.__magnificationFilter
    @magnificationFilter.setter
    def magnificationFilter(self, value = "FASTEST"):
        if 'AVG_PIXEL' == value:
            pass
        elif 'DEFAULT' == value:
            pass
        elif 'FASTEST' == value:
            pass
        elif 'NEAREST_PIXEL' == value:
            pass
        elif 'NICEST' == value:
            pass
        else:
            return None
        self.__magnificationFilter = [value]
    def setMagnificationFilter(self, magnificationFilter = "FASTEST"):
        if 'AVG_PIXEL' == magnificationFilter:
            pass
        elif 'DEFAULT' == magnificationFilter:
            pass
        elif 'FASTEST' == magnificationFilter:
            pass
        elif 'NEAREST_PIXEL' == magnificationFilter:
            pass
        elif 'NICEST' == magnificationFilter:
            pass
        else:
            return None
        self.__magnificationFilter = [magnificationFilter]
        return self
    def addMagnificationFilter(self, magnificationFilter = "FASTEST"):
        if 'AVG_PIXEL' == magnificationFilter:
            pass
        elif 'DEFAULT' == magnificationFilter:
            pass
        elif 'FASTEST' == magnificationFilter:
            pass
        elif 'NEAREST_PIXEL' == magnificationFilter:
            pass
        elif 'NICEST' == magnificationFilter:
            pass
        else:
            return None
        if self.__magnificationFilter == None:            self.__magnificationFilter =  []
        self.__magnificationFilter +=  [magnificationFilter]
        return self
    def removeMagnificationFilter(self, magnificationFilter):
        self.__magnificationFilter = [x for x in self.__magnificationFilter if x not in magnificationFilter]
        return self.__magnificationFilter
    def getMagnificationFilter(self, magnificationFilter = "FASTEST"):
        return self.__magnificationFilter
    def magnificationFilter_changed(self, magnificationFilter = "FASTEST"):
        return self.__magnificationFilter
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def minificationFilter(self):
        return self.__minificationFilter
    @minificationFilter.setter
    def minificationFilter(self, value = "FASTEST"):
        if 'AVG_PIXEL' == value:
            pass
        elif 'AVG_PIXEL_AVG_MIPMAP' == value:
            pass
        elif 'AVG_PIXEL_NEAREST_MIPMAP' == value:
            pass
        elif 'DEFAULT' == value:
            pass
        elif 'FASTEST' == value:
            pass
        elif 'NEAREST_PIXEL' == value:
            pass
        elif 'NEAREST_PIXEL_AVG_MIPMAP' == value:
            pass
        elif 'NEAREST_PIXEL_NEAREST_MIPMAP' == value:
            pass
        elif 'NICEST' == value:
            pass
        else:
            return None
        self.__minificationFilter = [value]
    def setMinificationFilter(self, minificationFilter = "FASTEST"):
        if 'AVG_PIXEL' == minificationFilter:
            pass
        elif 'AVG_PIXEL_AVG_MIPMAP' == minificationFilter:
            pass
        elif 'AVG_PIXEL_NEAREST_MIPMAP' == minificationFilter:
            pass
        elif 'DEFAULT' == minificationFilter:
            pass
        elif 'FASTEST' == minificationFilter:
            pass
        elif 'NEAREST_PIXEL' == minificationFilter:
            pass
        elif 'NEAREST_PIXEL_AVG_MIPMAP' == minificationFilter:
            pass
        elif 'NEAREST_PIXEL_NEAREST_MIPMAP' == minificationFilter:
            pass
        elif 'NICEST' == minificationFilter:
            pass
        else:
            return None
        self.__minificationFilter = [minificationFilter]
        return self
    def addMinificationFilter(self, minificationFilter = "FASTEST"):
        if 'AVG_PIXEL' == minificationFilter:
            pass
        elif 'AVG_PIXEL_AVG_MIPMAP' == minificationFilter:
            pass
        elif 'AVG_PIXEL_NEAREST_MIPMAP' == minificationFilter:
            pass
        elif 'DEFAULT' == minificationFilter:
            pass
        elif 'FASTEST' == minificationFilter:
            pass
        elif 'NEAREST_PIXEL' == minificationFilter:
            pass
        elif 'NEAREST_PIXEL_AVG_MIPMAP' == minificationFilter:
            pass
        elif 'NEAREST_PIXEL_NEAREST_MIPMAP' == minificationFilter:
            pass
        elif 'NICEST' == minificationFilter:
            pass
        else:
            return None
        if self.__minificationFilter == None:            self.__minificationFilter =  []
        self.__minificationFilter +=  [minificationFilter]
        return self
    def removeMinificationFilter(self, minificationFilter):
        self.__minificationFilter = [x for x in self.__minificationFilter if x not in minificationFilter]
        return self.__minificationFilter
    def getMinificationFilter(self, minificationFilter = "FASTEST"):
        return self.__minificationFilter
    def minificationFilter_changed(self, minificationFilter = "FASTEST"):
        return self.__minificationFilter
    @property
    def textureCompression(self):
        return self.__textureCompression
    @textureCompression.setter
    def textureCompression(self, value = "FASTEST"):
        if 'DEFAULT' == value:
            pass
        elif 'FASTEST' == value:
            pass
        elif 'HIGH' == value:
            pass
        elif 'LOW' == value:
            pass
        elif 'MEDIUM' == value:
            pass
        elif 'NICEST' == value:
            pass
        else:
            return None
        self.__textureCompression = [value]
    def setTextureCompression(self, textureCompression = "FASTEST"):
        if 'DEFAULT' == textureCompression:
            pass
        elif 'FASTEST' == textureCompression:
            pass
        elif 'HIGH' == textureCompression:
            pass
        elif 'LOW' == textureCompression:
            pass
        elif 'MEDIUM' == textureCompression:
            pass
        elif 'NICEST' == textureCompression:
            pass
        else:
            return None
        self.__textureCompression = [textureCompression]
        return self
    def addTextureCompression(self, textureCompression = "FASTEST"):
        if 'DEFAULT' == textureCompression:
            pass
        elif 'FASTEST' == textureCompression:
            pass
        elif 'HIGH' == textureCompression:
            pass
        elif 'LOW' == textureCompression:
            pass
        elif 'MEDIUM' == textureCompression:
            pass
        elif 'NICEST' == textureCompression:
            pass
        else:
            return None
        if self.__textureCompression == None:            self.__textureCompression =  []
        self.__textureCompression +=  [textureCompression]
        return self
    def removeTextureCompression(self, textureCompression):
        self.__textureCompression = [x for x in self.__textureCompression if x not in textureCompression]
        return self.__textureCompression
    def getTextureCompression(self, textureCompression = "FASTEST"):
        return self.__textureCompression
    def textureCompression_changed(self, textureCompression = "FASTEST"):
        return self.__textureCompression
    @property
    def texturePriority(self):
        return self.__texturePriority
    @texturePriority.setter
    def texturePriority(self, value = 0):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__texturePriority = [value]
    def setTexturePriority(self, texturePriority = 0):
        if texturePriority == None or texturePriority  <  0:
            return None
        if texturePriority == None or texturePriority  >  1:
            return None
        self.__texturePriority = [texturePriority]
        return self
    def addTexturePriority(self, texturePriority = 0):
        if texturePriority == None or texturePriority  <  0:
            return None
        if texturePriority == None or texturePriority  >  1:
            return None
        if self.__texturePriority == None:            self.__texturePriority =  []
        self.__texturePriority +=  [texturePriority]
        return self
    def removeTexturePriority(self, texturePriority):
        self.__texturePriority = [x for x in self.__texturePriority if x not in texturePriority]
        return self.__texturePriority
    def getTexturePriority(self, texturePriority = 0):
        return self.__texturePriority
    def texturePriority_changed(self, texturePriority = 0):
        return self.__texturePriority
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<TextureProperties'
        if self.__anisotropicDegree is not None:
            if isinstance(self.__anisotropicDegree, six.string_types):
                str += ' anisotropicDegree="'+self.__anisotropicDegree+'"'
            else:
                str += ' anisotropicDegree="'+self.__anisotropicDegree[0]+'"'
        if self.__borderColor is not None:
            if isinstance(self.__borderColor, six.string_types):
                str += ' borderColor="'+self.__borderColor+'"'
            else:
                str += ' borderColor="'+self.__borderColor[0]+'"'
        if self.__borderWidth is not None:
            if isinstance(self.__borderWidth, six.string_types):
                str += ' borderWidth="'+self.__borderWidth+'"'
            else:
                str += ' borderWidth="'+self.__borderWidth[0]+'"'
        if self.__boundaryModeR is not None:
            if isinstance(self.__boundaryModeR, six.string_types):
                str += ' boundaryModeR="'+self.__boundaryModeR+'"'
            else:
                str += ' boundaryModeR="'+self.__boundaryModeR[0]+'"'
        if self.__boundaryModeS is not None:
            if isinstance(self.__boundaryModeS, six.string_types):
                str += ' boundaryModeS="'+self.__boundaryModeS+'"'
            else:
                str += ' boundaryModeS="'+self.__boundaryModeS[0]+'"'
        if self.__boundaryModeT is not None:
            if isinstance(self.__boundaryModeT, six.string_types):
                str += ' boundaryModeT="'+self.__boundaryModeT+'"'
            else:
                str += ' boundaryModeT="'+self.__boundaryModeT[0]+'"'
        if self.__generateMipMaps is not None:
            if isinstance(self.__generateMipMaps, six.string_types):
                str += ' generateMipMaps="'+self.__generateMipMaps+'"'
            else:
                str += ' generateMipMaps="'+self.__generateMipMaps[0]+'"'
        if self.__magnificationFilter is not None:
            if isinstance(self.__magnificationFilter, six.string_types):
                str += ' magnificationFilter="'+self.__magnificationFilter+'"'
            else:
                str += ' magnificationFilter="'+self.__magnificationFilter[0]+'"'
        if self.__minificationFilter is not None:
            if isinstance(self.__minificationFilter, six.string_types):
                str += ' minificationFilter="'+self.__minificationFilter+'"'
            else:
                str += ' minificationFilter="'+self.__minificationFilter[0]+'"'
        if self.__textureCompression is not None:
            if isinstance(self.__textureCompression, six.string_types):
                str += ' textureCompression="'+self.__textureCompression+'"'
            else:
                str += ' textureCompression="'+self.__textureCompression[0]+'"'
        if self.__texturePriority is not None:
            if isinstance(self.__texturePriority, six.string_types):
                str += ' texturePriority="'+self.__texturePriority+'"'
            else:
                str += ' texturePriority="'+self.__texturePriority[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</TextureProperties>'
        return str


class TextureTransform(X3DTextureTransformNode):
    def __init__(self, **kwargs):
        super(TextureTransform, self).__init__(**kwargs)
        center  = kwargs.pop("center", [0, 0])
        self.__center = center
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        rotation  = kwargs.pop("rotation", 0)
        self.__rotation = rotation
        scale  = kwargs.pop("scale", [1, 1])
        self.__scale = scale
        translation  = kwargs.pop("translation", [0, 0])
        self.__translation = translation
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def center(self):
        return self.__center
    @center.setter
    def center(self, value = [0, 0]):
        self.__center = [value]
    def setCenter(self, center = [0, 0]):
        self.__center = [center]
        return self
    def addCenter(self, center = [0, 0]):
        if self.__center == None:            self.__center =  []
        self.__center +=  [center]
        return self
    def removeCenter(self, center):
        self.__center = [x for x in self.__center if x not in center]
        return self.__center
    def getCenter(self, center = [0, 0]):
        return self.__center
    def center_changed(self, center = [0, 0]):
        return self.__center
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def rotation(self):
        return self.__rotation
    @rotation.setter
    def rotation(self, value = 0):
        self.__rotation = [value]
    def setRotation(self, rotation = 0):
        self.__rotation = [rotation]
        return self
    def addRotation(self, rotation = 0):
        if self.__rotation == None:            self.__rotation =  []
        self.__rotation +=  [rotation]
        return self
    def removeRotation(self, rotation):
        self.__rotation = [x for x in self.__rotation if x not in rotation]
        return self.__rotation
    def getRotation(self, rotation = 0):
        return self.__rotation
    def rotation_changed(self, rotation = 0):
        return self.__rotation
    @property
    def scale(self):
        return self.__scale
    @scale.setter
    def scale(self, value = [1, 1]):
        self.__scale = [value]
    def setScale(self, scale = [1, 1]):
        self.__scale = [scale]
        return self
    def addScale(self, scale = [1, 1]):
        if self.__scale == None:            self.__scale =  []
        self.__scale +=  [scale]
        return self
    def removeScale(self, scale):
        self.__scale = [x for x in self.__scale if x not in scale]
        return self.__scale
    def getScale(self, scale = [1, 1]):
        return self.__scale
    def scale_changed(self, scale = [1, 1]):
        return self.__scale
    @property
    def translation(self):
        return self.__translation
    @translation.setter
    def translation(self, value = [0, 0]):
        self.__translation = [value]
    def setTranslation(self, translation = [0, 0]):
        self.__translation = [translation]
        return self
    def addTranslation(self, translation = [0, 0]):
        if self.__translation == None:            self.__translation =  []
        self.__translation +=  [translation]
        return self
    def removeTranslation(self, translation):
        self.__translation = [x for x in self.__translation if x not in translation]
        return self.__translation
    def getTranslation(self, translation = [0, 0]):
        return self.__translation
    def translation_changed(self, translation = [0, 0]):
        return self.__translation
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<TextureTransform'
        if self.__center is not None:
            if isinstance(self.__center, six.string_types):
                str += ' center="'+self.__center+'"'
            else:
                str += ' center="'+self.__center[0]+'"'
        if self.__rotation is not None:
            if isinstance(self.__rotation, six.string_types):
                str += ' rotation="'+self.__rotation+'"'
            else:
                str += ' rotation="'+self.__rotation[0]+'"'
        if self.__scale is not None:
            if isinstance(self.__scale, six.string_types):
                str += ' scale="'+self.__scale+'"'
            else:
                str += ' scale="'+self.__scale[0]+'"'
        if self.__translation is not None:
            if isinstance(self.__translation, six.string_types):
                str += ' translation="'+self.__translation+'"'
            else:
                str += ' translation="'+self.__translation[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</TextureTransform>'
        return str


class TextureTransform3D(X3DTextureTransformNode):
    def __init__(self, **kwargs):
        super(TextureTransform3D, self).__init__(**kwargs)
        center  = kwargs.pop("center", [0, 0, 0])
        self.__center = center
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        rotation  = kwargs.pop("rotation", [0, 0, 1, 0])
        self.__rotation = rotation
        scale  = kwargs.pop("scale", [1, 1, 1])
        self.__scale = scale
        translation  = kwargs.pop("translation", [0, 0, 0])
        self.__translation = translation
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def center(self):
        return self.__center
    @center.setter
    def center(self, value = [0, 0, 0]):
        self.__center = [value]
    def setCenter(self, center = [0, 0, 0]):
        self.__center = [center]
        return self
    def addCenter(self, center = [0, 0, 0]):
        if self.__center == None:            self.__center =  []
        self.__center +=  [center]
        return self
    def removeCenter(self, center):
        self.__center = [x for x in self.__center if x not in center]
        return self.__center
    def getCenter(self, center = [0, 0, 0]):
        return self.__center
    def center_changed(self, center = [0, 0, 0]):
        return self.__center
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def rotation(self):
        return self.__rotation
    @rotation.setter
    def rotation(self, value = [0, 0, 1, 0]):
        self.__rotation = [value]
    def setRotation(self, rotation = [0, 0, 1, 0]):
        self.__rotation = [rotation]
        return self
    def addRotation(self, rotation = [0, 0, 1, 0]):
        if self.__rotation == None:            self.__rotation =  []
        self.__rotation +=  [rotation]
        return self
    def removeRotation(self, rotation):
        self.__rotation = [x for x in self.__rotation if x not in rotation]
        return self.__rotation
    def getRotation(self, rotation = [0, 0, 1, 0]):
        return self.__rotation
    def rotation_changed(self, rotation = [0, 0, 1, 0]):
        return self.__rotation
    @property
    def scale(self):
        return self.__scale
    @scale.setter
    def scale(self, value = [1, 1, 1]):
        self.__scale = [value]
    def setScale(self, scale = [1, 1, 1]):
        self.__scale = [scale]
        return self
    def addScale(self, scale = [1, 1, 1]):
        if self.__scale == None:            self.__scale =  []
        self.__scale +=  [scale]
        return self
    def removeScale(self, scale):
        self.__scale = [x for x in self.__scale if x not in scale]
        return self.__scale
    def getScale(self, scale = [1, 1, 1]):
        return self.__scale
    def scale_changed(self, scale = [1, 1, 1]):
        return self.__scale
    @property
    def translation(self):
        return self.__translation
    @translation.setter
    def translation(self, value = [0, 0, 0]):
        self.__translation = [value]
    def setTranslation(self, translation = [0, 0, 0]):
        self.__translation = [translation]
        return self
    def addTranslation(self, translation = [0, 0, 0]):
        if self.__translation == None:            self.__translation =  []
        self.__translation +=  [translation]
        return self
    def removeTranslation(self, translation):
        self.__translation = [x for x in self.__translation if x not in translation]
        return self.__translation
    def getTranslation(self, translation = [0, 0, 0]):
        return self.__translation
    def translation_changed(self, translation = [0, 0, 0]):
        return self.__translation
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<TextureTransform3D'
        if self.__center is not None:
            if isinstance(self.__center, six.string_types):
                str += ' center="'+self.__center+'"'
            else:
                str += ' center="'+self.__center[0]+'"'
        if self.__rotation is not None:
            if isinstance(self.__rotation, six.string_types):
                str += ' rotation="'+self.__rotation+'"'
            else:
                str += ' rotation="'+self.__rotation[0]+'"'
        if self.__scale is not None:
            if isinstance(self.__scale, six.string_types):
                str += ' scale="'+self.__scale+'"'
            else:
                str += ' scale="'+self.__scale[0]+'"'
        if self.__translation is not None:
            if isinstance(self.__translation, six.string_types):
                str += ' translation="'+self.__translation+'"'
            else:
                str += ' translation="'+self.__translation[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</TextureTransform3D>'
        return str


class TextureTransformMatrix3D(X3DTextureTransformNode):
    def __init__(self, **kwargs):
        super(TextureTransformMatrix3D, self).__init__(**kwargs)
        matrix  = kwargs.pop("matrix", [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])
        self.__matrix = matrix
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def matrix(self):
        return self.__matrix
    @matrix.setter
    def matrix(self, value = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]):
        self.__matrix = [value]
    def setMatrix(self, matrix = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]):
        self.__matrix = [matrix]
        return self
    def addMatrix(self, matrix = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]):
        if self.__matrix == None:            self.__matrix =  []
        self.__matrix +=  [matrix]
        return self
    def removeMatrix(self, matrix):
        self.__matrix = [x for x in self.__matrix if x not in matrix]
        return self.__matrix
    def getMatrix(self, matrix = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]):
        return self.__matrix
    def matrix_changed(self, matrix = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]):
        return self.__matrix
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<TextureTransformMatrix3D'
        if self.__matrix is not None:
            if isinstance(self.__matrix, six.string_types):
                str += ' matrix="'+self.__matrix+'"'
            else:
                str += ' matrix="'+self.__matrix[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</TextureTransformMatrix3D>'
        return str


class TimeSensor(X3DSensorNode, X3DTimeDependentNode):
    def __init__(self, **kwargs):
        super(TimeSensor, self).__init__(**kwargs)
        cycleInterval  = kwargs.pop("cycleInterval", 1.0)
        if cycleInterval == None or cycleInterval  <  0:
            return None
        self.__cycleInterval = cycleInterval
        cycleTime  = kwargs.pop("cycleTime", None)
        if cycleTime == None or cycleTime  <  0:
            return None
        self.__cycleTime = cycleTime
        elapsedTime  = kwargs.pop("elapsedTime", None)
        if elapsedTime == None or elapsedTime  <  0:
            return None
        self.__elapsedTime = elapsedTime
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        fraction_changed  = kwargs.pop("fraction_changed", None)
        self.__fraction_changed = fraction_changed
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        Paused  = kwargs.pop("Paused", None)
        self.__Paused = Paused
        loop  = kwargs.pop("loop", False)
        self.__loop = loop
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        pauseTime  = kwargs.pop("pauseTime", 0)
        self.__pauseTime = pauseTime
        resumeTime  = kwargs.pop("resumeTime", 0)
        self.__resumeTime = resumeTime
        startTime  = kwargs.pop("startTime", 0)
        self.__startTime = startTime
        stopTime  = kwargs.pop("stopTime", 0)
        self.__stopTime = stopTime
        time  = kwargs.pop("time", None)
        if time == None or time  <  0:
            return None
        self.__time = time
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def cycleInterval(self):
        return self.__cycleInterval
    @cycleInterval.setter
    def cycleInterval(self, value = 1.0):
        if value == None or value  <  0:
            return None
        self.__cycleInterval = [value]
    def setCycleInterval(self, cycleInterval = 1.0):
        if cycleInterval == None or cycleInterval  <  0:
            return None
        self.__cycleInterval = [cycleInterval]
        return self
    def addCycleInterval(self, cycleInterval = 1.0):
        if cycleInterval == None or cycleInterval  <  0:
            return None
        if self.__cycleInterval == None:            self.__cycleInterval =  []
        self.__cycleInterval +=  [cycleInterval]
        return self
    def removeCycleInterval(self, cycleInterval):
        self.__cycleInterval = [x for x in self.__cycleInterval if x not in cycleInterval]
        return self.__cycleInterval
    def getCycleInterval(self, cycleInterval = 1.0):
        return self.__cycleInterval
    def cycleInterval_changed(self, cycleInterval = 1.0):
        return self.__cycleInterval
    def removeCycleTime(self, cycleTime):
        self.__cycleTime = [x for x in self.__cycleTime if x not in cycleTime]
        return self.__cycleTime
    def getCycleTime(self, cycleTime = None):
        return self.__cycleTime
    def cycleTime_changed(self, cycleTime = None):
        return self.__cycleTime
    def removeElapsedTime(self, elapsedTime):
        self.__elapsedTime = [x for x in self.__elapsedTime if x not in elapsedTime]
        return self.__elapsedTime
    def getElapsedTime(self, elapsedTime = None):
        return self.__elapsedTime
    def elapsedTime_changed(self, elapsedTime = None):
        return self.__elapsedTime
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    def removefraction_changed(self, fraction_changed):
        self.__fraction_changed = [x for x in self.__fraction_changed if x not in fraction_changed]
        return self.__fraction_changed
    def getfraction_changed(self, fraction_changed = None):
        return self.__fraction_changed
    def fraction_changed_changed(self, fraction_changed = None):
        return self.__fraction_changed
    def isActive(self, Active = None):
        return self.__Active
    def isPaused(self, Paused = None):
        return self.__Paused
    @property
    def loop(self):
        return self.__loop
    @loop.setter
    def loop(self, value = False):
        self.__loop = [value]
    def setLoop(self, loop = False):
        self.__loop = [loop]
        return self
    def addLoop(self, loop = False):
        if self.__loop == None:            self.__loop =  []
        self.__loop +=  [loop]
        return self
    def removeLoop(self, loop):
        self.__loop = [x for x in self.__loop if x not in loop]
        return self.__loop
    def isLoop(self, loop = False):
        return self.__loop
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def pauseTime(self):
        return self.__pauseTime
    @pauseTime.setter
    def pauseTime(self, value = 0):
        self.__pauseTime = [value]
    def setPauseTime(self, pauseTime = 0):
        self.__pauseTime = [pauseTime]
        return self
    def addPauseTime(self, pauseTime = 0):
        if self.__pauseTime == None:            self.__pauseTime =  []
        self.__pauseTime +=  [pauseTime]
        return self
    def removePauseTime(self, pauseTime):
        self.__pauseTime = [x for x in self.__pauseTime if x not in pauseTime]
        return self.__pauseTime
    def getPauseTime(self, pauseTime = 0):
        return self.__pauseTime
    def pauseTime_changed(self, pauseTime = 0):
        return self.__pauseTime
    @property
    def resumeTime(self):
        return self.__resumeTime
    @resumeTime.setter
    def resumeTime(self, value = 0):
        self.__resumeTime = [value]
    def setResumeTime(self, resumeTime = 0):
        self.__resumeTime = [resumeTime]
        return self
    def addResumeTime(self, resumeTime = 0):
        if self.__resumeTime == None:            self.__resumeTime =  []
        self.__resumeTime +=  [resumeTime]
        return self
    def removeResumeTime(self, resumeTime):
        self.__resumeTime = [x for x in self.__resumeTime if x not in resumeTime]
        return self.__resumeTime
    def getResumeTime(self, resumeTime = 0):
        return self.__resumeTime
    def resumeTime_changed(self, resumeTime = 0):
        return self.__resumeTime
    @property
    def startTime(self):
        return self.__startTime
    @startTime.setter
    def startTime(self, value = 0):
        self.__startTime = [value]
    def setStartTime(self, startTime = 0):
        self.__startTime = [startTime]
        return self
    def addStartTime(self, startTime = 0):
        if self.__startTime == None:            self.__startTime =  []
        self.__startTime +=  [startTime]
        return self
    def removeStartTime(self, startTime):
        self.__startTime = [x for x in self.__startTime if x not in startTime]
        return self.__startTime
    def getStartTime(self, startTime = 0):
        return self.__startTime
    def startTime_changed(self, startTime = 0):
        return self.__startTime
    @property
    def stopTime(self):
        return self.__stopTime
    @stopTime.setter
    def stopTime(self, value = 0):
        self.__stopTime = [value]
    def setStopTime(self, stopTime = 0):
        self.__stopTime = [stopTime]
        return self
    def addStopTime(self, stopTime = 0):
        if self.__stopTime == None:            self.__stopTime =  []
        self.__stopTime +=  [stopTime]
        return self
    def removeStopTime(self, stopTime):
        self.__stopTime = [x for x in self.__stopTime if x not in stopTime]
        return self.__stopTime
    def getStopTime(self, stopTime = 0):
        return self.__stopTime
    def stopTime_changed(self, stopTime = 0):
        return self.__stopTime
    def removeTime(self, time):
        self.__time = [x for x in self.__time if x not in time]
        return self.__time
    def getTime(self, time = None):
        return self.__time
    def time_changed(self, time = None):
        return self.__time
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<TimeSensor'
        if self.__cycleInterval is not None:
            if isinstance(self.__cycleInterval, six.string_types):
                str += ' cycleInterval="'+self.__cycleInterval+'"'
            else:
                str += ' cycleInterval="'+self.__cycleInterval[0]+'"'
        if self.__cycleTime is not None:
            if isinstance(self.__cycleTime, six.string_types):
                str += ' cycleTime="'+self.__cycleTime+'"'
            else:
                str += ' cycleTime="'+self.__cycleTime[0]+'"'
        if self.__elapsedTime is not None:
            if isinstance(self.__elapsedTime, six.string_types):
                str += ' elapsedTime="'+self.__elapsedTime+'"'
            else:
                str += ' elapsedTime="'+self.__elapsedTime[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__fraction_changed is not None:
            if isinstance(self.__fraction_changed, six.string_types):
                str += ' fraction_changed="'+self.__fraction_changed+'"'
            else:
                str += ' fraction_changed="'+self.__fraction_changed[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__Paused is not None:
            if isinstance(self.__Paused, six.string_types):
                str += ' Paused="'+self.__Paused+'"'
            else:
                str += ' Paused="'+self.__Paused[0]+'"'
        if self.__loop is not None:
            if isinstance(self.__loop, six.string_types):
                str += ' loop="'+self.__loop+'"'
            else:
                str += ' loop="'+self.__loop[0]+'"'
        if self.__pauseTime is not None:
            if isinstance(self.__pauseTime, six.string_types):
                str += ' pauseTime="'+self.__pauseTime+'"'
            else:
                str += ' pauseTime="'+self.__pauseTime[0]+'"'
        if self.__resumeTime is not None:
            if isinstance(self.__resumeTime, six.string_types):
                str += ' resumeTime="'+self.__resumeTime+'"'
            else:
                str += ' resumeTime="'+self.__resumeTime[0]+'"'
        if self.__startTime is not None:
            if isinstance(self.__startTime, six.string_types):
                str += ' startTime="'+self.__startTime+'"'
            else:
                str += ' startTime="'+self.__startTime[0]+'"'
        if self.__stopTime is not None:
            if isinstance(self.__stopTime, six.string_types):
                str += ' stopTime="'+self.__stopTime+'"'
            else:
                str += ' stopTime="'+self.__stopTime[0]+'"'
        if self.__time is not None:
            if isinstance(self.__time, six.string_types):
                str += ' time="'+self.__time+'"'
            else:
                str += ' time="'+self.__time[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</TimeSensor>'
        return str


class TimeTrigger(X3DTriggerNode):
    def __init__(self, **kwargs):
        super(TimeTrigger, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        boolean  = kwargs.pop("boolean", None)
        self.__boolean = boolean
        triggerTime  = kwargs.pop("triggerTime", None)
        self.__triggerTime = triggerTime
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def boolean(self):
        return self.__boolean
    @boolean.setter
    def boolean(self, value = None):
        self.__boolean = [value]
    def set_boolean(self, boolean = None):
        self.__boolean = [boolean]
        return self
    def removeTriggerTime(self, triggerTime):
        self.__triggerTime = [x for x in self.__triggerTime if x not in triggerTime]
        return self.__triggerTime
    def getTriggerTime(self, triggerTime = None):
        return self.__triggerTime
    def triggerTime_changed(self, triggerTime = None):
        return self.__triggerTime
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<TimeTrigger'
        if self.__boolean is not None:
            if isinstance(self.__boolean, six.string_types):
                str += ' boolean="'+self.__boolean+'"'
            else:
                str += ' boolean="'+self.__boolean[0]+'"'
        if self.__triggerTime is not None:
            if isinstance(self.__triggerTime, six.string_types):
                str += ' triggerTime="'+self.__triggerTime+'"'
            else:
                str += ' triggerTime="'+self.__triggerTime[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</TimeTrigger>'
        return str


class ToneMappedVolumeStyle(X3DComposableVolumeRenderStyleNode):
    def __init__(self, **kwargs):
        super(ToneMappedVolumeStyle, self).__init__(**kwargs)
        coolColor  = kwargs.pop("coolColor", [0, 0, 1, 0])
        if coolColor == None or coolColor  <  0:
            return None
        if coolColor == None or coolColor  >  1:
            return None
        self.__coolColor = coolColor
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        surfaceNormals  = kwargs.pop("surfaceNormals", None)
        self.__surfaceNormals = surfaceNormals
        warmColor  = kwargs.pop("warmColor", [1, 1, 0, 0])
        if warmColor == None or warmColor  <  0:
            return None
        if warmColor == None or warmColor  >  1:
            return None
        self.__warmColor = warmColor
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def coolColor(self):
        return self.__coolColor
    @coolColor.setter
    def coolColor(self, value = [0, 0, 1, 0]):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__coolColor = [value]
    def setCoolColor(self, coolColor = [0, 0, 1, 0]):
        if coolColor == None or coolColor  <  0:
            return None
        if coolColor == None or coolColor  >  1:
            return None
        self.__coolColor = [coolColor]
        return self
    def addCoolColor(self, coolColor = [0, 0, 1, 0]):
        if coolColor == None or coolColor  <  0:
            return None
        if coolColor == None or coolColor  >  1:
            return None
        if self.__coolColor == None:            self.__coolColor =  []
        self.__coolColor +=  [coolColor]
        return self
    def removeCoolColor(self, coolColor):
        self.__coolColor = [x for x in self.__coolColor if x not in coolColor]
        return self.__coolColor
    def getCoolColor(self, coolColor = [0, 0, 1, 0]):
        return self.__coolColor
    def coolColor_changed(self, coolColor = [0, 0, 1, 0]):
        return self.__coolColor
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def surfaceNormals(self):
        return self.__surfaceNormals
    @surfaceNormals.setter
    def surfaceNormals(self, value = None):
        self.__surfaceNormals = [value]
    def setSurfaceNormals(self, surfaceNormals = None):
        self.__surfaceNormals = [surfaceNormals]
        return self
    def addSurfaceNormals(self, surfaceNormals = None):
        if self.__surfaceNormals == None:            self.__surfaceNormals =  []
        self.__surfaceNormals +=  [surfaceNormals]
        return self
    def removeSurfaceNormals(self, surfaceNormals):
        self.__surfaceNormals = [x for x in self.__surfaceNormals if x not in surfaceNormals]
        return self.__surfaceNormals
    def getSurfaceNormals(self, surfaceNormals = None):
        return self.__surfaceNormals
    def surfaceNormals_changed(self, surfaceNormals = None):
        return self.__surfaceNormals
    @property
    def warmColor(self):
        return self.__warmColor
    @warmColor.setter
    def warmColor(self, value = [1, 1, 0, 0]):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__warmColor = [value]
    def setWarmColor(self, warmColor = [1, 1, 0, 0]):
        if warmColor == None or warmColor  <  0:
            return None
        if warmColor == None or warmColor  >  1:
            return None
        self.__warmColor = [warmColor]
        return self
    def addWarmColor(self, warmColor = [1, 1, 0, 0]):
        if warmColor == None or warmColor  <  0:
            return None
        if warmColor == None or warmColor  >  1:
            return None
        if self.__warmColor == None:            self.__warmColor =  []
        self.__warmColor +=  [warmColor]
        return self
    def removeWarmColor(self, warmColor):
        self.__warmColor = [x for x in self.__warmColor if x not in warmColor]
        return self.__warmColor
    def getWarmColor(self, warmColor = [1, 1, 0, 0]):
        return self.__warmColor
    def warmColor_changed(self, warmColor = [1, 1, 0, 0]):
        return self.__warmColor
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ToneMappedVolumeStyle'
        if self.__coolColor is not None:
            if isinstance(self.__coolColor, six.string_types):
                str += ' coolColor="'+self.__coolColor+'"'
            else:
                str += ' coolColor="'+self.__coolColor[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__warmColor is not None:
            if isinstance(self.__warmColor, six.string_types):
                str += ' warmColor="'+self.__warmColor+'"'
            else:
                str += ' warmColor="'+self.__warmColor[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<surfaceNormals'
        if self.__surfaceNormals is not None:
           for s in self.__surfaceNormals:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__surfaceNormals is not None:
           for s in self.__surfaceNormals:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</surfaceNormals>'
        str += '</ToneMappedVolumeStyle>'
        return str


class TouchSensor(X3DTouchSensorNode):
    def __init__(self, **kwargs):
        super(TouchSensor, self).__init__(**kwargs)
        description  = kwargs.pop("description", None)
        self.__description = description
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        hitNormal_changed  = kwargs.pop("hitNormal_changed", None)
        self.__hitNormal_changed = hitNormal_changed
        hitPoint_changed  = kwargs.pop("hitPoint_changed", None)
        self.__hitPoint_changed = hitPoint_changed
        hitTexCoord_changed  = kwargs.pop("hitTexCoord_changed", None)
        self.__hitTexCoord_changed = hitTexCoord_changed
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        Over  = kwargs.pop("Over", None)
        self.__Over = Over
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        touchTime  = kwargs.pop("touchTime", None)
        self.__touchTime = touchTime
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def description(self):
        return self.__description
    @description.setter
    def description(self, value = None):
        self.__description = [value]
    def setDescription(self, description = None):
        self.__description = [description]
        return self
    def addDescription(self, description = None):
        if self.__description == None:            self.__description =  []
        self.__description +=  [description]
        return self
    def removeDescription(self, description):
        self.__description = [x for x in self.__description if x not in description]
        return self.__description
    def getDescription(self, description = None):
        return self.__description
    def description_changed(self, description = None):
        return self.__description
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    def removehitNormal_changed(self, hitNormal_changed):
        self.__hitNormal_changed = [x for x in self.__hitNormal_changed if x not in hitNormal_changed]
        return self.__hitNormal_changed
    def gethitNormal_changed(self, hitNormal_changed = None):
        return self.__hitNormal_changed
    def hitNormal_changed_changed(self, hitNormal_changed = None):
        return self.__hitNormal_changed
    def removehitPoint_changed(self, hitPoint_changed):
        self.__hitPoint_changed = [x for x in self.__hitPoint_changed if x not in hitPoint_changed]
        return self.__hitPoint_changed
    def gethitPoint_changed(self, hitPoint_changed = None):
        return self.__hitPoint_changed
    def hitPoint_changed_changed(self, hitPoint_changed = None):
        return self.__hitPoint_changed
    def removehitTexCoord_changed(self, hitTexCoord_changed):
        self.__hitTexCoord_changed = [x for x in self.__hitTexCoord_changed if x not in hitTexCoord_changed]
        return self.__hitTexCoord_changed
    def gethitTexCoord_changed(self, hitTexCoord_changed = None):
        return self.__hitTexCoord_changed
    def hitTexCoord_changed_changed(self, hitTexCoord_changed = None):
        return self.__hitTexCoord_changed
    def isActive(self, Active = None):
        return self.__Active
    def isOver(self, Over = None):
        return self.__Over
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    def removeTouchTime(self, touchTime):
        self.__touchTime = [x for x in self.__touchTime if x not in touchTime]
        return self.__touchTime
    def getTouchTime(self, touchTime = None):
        return self.__touchTime
    def touchTime_changed(self, touchTime = None):
        return self.__touchTime
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    @property
    def IS(self):
        return self.__IS
    @IS.setter
    def IS(self, value = None):
        self.__IS = [value]
    def setIS(self, IS = None):
        self.__IS = [IS]
        return self
    def addIS(self, IS = None):
        if self.__IS == None:            self.__IS =  []
        self.__IS +=  [IS]
        return self
    def removeIS(self, IS):
        self.__IS = [x for x in self.__IS if x not in IS]
        return self.__IS
    def getIS(self, IS = None):
        return self.__IS
    def IS_changed(self, IS = None):
        return self.__IS
    def toXML(self):
        str = ''
        str += '<TouchSensor'
        if self.__description is not None:
            if isinstance(self.__description, six.string_types):
                str += ' description="'+self.__description+'"'
            else:
                str += ' description="'+self.__description[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__hitNormal_changed is not None:
            if isinstance(self.__hitNormal_changed, six.string_types):
                str += ' hitNormal_changed="'+self.__hitNormal_changed+'"'
            else:
                str += ' hitNormal_changed="'+self.__hitNormal_changed[0]+'"'
        if self.__hitPoint_changed is not None:
            if isinstance(self.__hitPoint_changed, six.string_types):
                str += ' hitPoint_changed="'+self.__hitPoint_changed+'"'
            else:
                str += ' hitPoint_changed="'+self.__hitPoint_changed[0]+'"'
        if self.__hitTexCoord_changed is not None:
            if isinstance(self.__hitTexCoord_changed, six.string_types):
                str += ' hitTexCoord_changed="'+self.__hitTexCoord_changed+'"'
            else:
                str += ' hitTexCoord_changed="'+self.__hitTexCoord_changed[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__Over is not None:
            if isinstance(self.__Over, six.string_types):
                str += ' Over="'+self.__Over+'"'
            else:
                str += ' Over="'+self.__Over[0]+'"'
        if self.__touchTime is not None:
            if isinstance(self.__touchTime, six.string_types):
                str += ' touchTime="'+self.__touchTime+'"'
            else:
                str += ' touchTime="'+self.__touchTime[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</TouchSensor>'
        return str


class Transform(X3DGroupingNode):
    def __init__(self, **kwargs):
        super(Transform, self).__init__(**kwargs)
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        center  = kwargs.pop("center", [0, 0, 0])
        self.__center = center
        children  = kwargs.pop("children", None)
        self.__children = children
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        rotation  = kwargs.pop("rotation", [0, 0, 1, 0])
        self.__rotation = rotation
        scale  = kwargs.pop("scale", [1, 1, 1])
        self.__scale = scale
        scaleOrientation  = kwargs.pop("scaleOrientation", [0, 0, 1, 0])
        self.__scaleOrientation = scaleOrientation
        translation  = kwargs.pop("translation", [0, 0, 0])
        self.__translation = translation
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    def addChildren(self, Children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [Children]
        return self
    @property
    def center(self):
        return self.__center
    @center.setter
    def center(self, value = [0, 0, 0]):
        self.__center = [value]
    def setCenter(self, center = [0, 0, 0]):
        self.__center = [center]
        return self
    def addCenter(self, center = [0, 0, 0]):
        if self.__center == None:            self.__center =  []
        self.__center +=  [center]
        return self
    def removeCenter(self, center):
        self.__center = [x for x in self.__center if x not in center]
        return self.__center
    def getCenter(self, center = [0, 0, 0]):
        return self.__center
    def center_changed(self, center = [0, 0, 0]):
        return self.__center
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    @property
    def rotation(self):
        return self.__rotation
    @rotation.setter
    def rotation(self, value = [0, 0, 1, 0]):
        self.__rotation = [value]
    def setRotation(self, rotation = [0, 0, 1, 0]):
        self.__rotation = [rotation]
        return self
    def addRotation(self, rotation = [0, 0, 1, 0]):
        if self.__rotation == None:            self.__rotation =  []
        self.__rotation +=  [rotation]
        return self
    def removeRotation(self, rotation):
        self.__rotation = [x for x in self.__rotation if x not in rotation]
        return self.__rotation
    def getRotation(self, rotation = [0, 0, 1, 0]):
        return self.__rotation
    def rotation_changed(self, rotation = [0, 0, 1, 0]):
        return self.__rotation
    @property
    def scale(self):
        return self.__scale
    @scale.setter
    def scale(self, value = [1, 1, 1]):
        self.__scale = [value]
    def setScale(self, scale = [1, 1, 1]):
        self.__scale = [scale]
        return self
    def addScale(self, scale = [1, 1, 1]):
        if self.__scale == None:            self.__scale =  []
        self.__scale +=  [scale]
        return self
    def removeScale(self, scale):
        self.__scale = [x for x in self.__scale if x not in scale]
        return self.__scale
    def getScale(self, scale = [1, 1, 1]):
        return self.__scale
    def scale_changed(self, scale = [1, 1, 1]):
        return self.__scale
    @property
    def scaleOrientation(self):
        return self.__scaleOrientation
    @scaleOrientation.setter
    def scaleOrientation(self, value = [0, 0, 1, 0]):
        self.__scaleOrientation = [value]
    def setScaleOrientation(self, scaleOrientation = [0, 0, 1, 0]):
        self.__scaleOrientation = [scaleOrientation]
        return self
    def addScaleOrientation(self, scaleOrientation = [0, 0, 1, 0]):
        if self.__scaleOrientation == None:            self.__scaleOrientation =  []
        self.__scaleOrientation +=  [scaleOrientation]
        return self
    def removeScaleOrientation(self, scaleOrientation):
        self.__scaleOrientation = [x for x in self.__scaleOrientation if x not in scaleOrientation]
        return self.__scaleOrientation
    def getScaleOrientation(self, scaleOrientation = [0, 0, 1, 0]):
        return self.__scaleOrientation
    def scaleOrientation_changed(self, scaleOrientation = [0, 0, 1, 0]):
        return self.__scaleOrientation
    @property
    def translation(self):
        return self.__translation
    @translation.setter
    def translation(self, value = [0, 0, 0]):
        self.__translation = [value]
    def setTranslation(self, translation = [0, 0, 0]):
        self.__translation = [translation]
        return self
    def addTranslation(self, translation = [0, 0, 0]):
        if self.__translation == None:            self.__translation =  []
        self.__translation +=  [translation]
        return self
    def removeTranslation(self, translation):
        self.__translation = [x for x in self.__translation if x not in translation]
        return self.__translation
    def getTranslation(self, translation = [0, 0, 0]):
        return self.__translation
    def translation_changed(self, translation = [0, 0, 0]):
        return self.__translation
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    @property
    def IS(self):
        return self.__IS
    @IS.setter
    def IS(self, value = None):
        self.__IS = [value]
    def setIS(self, IS = None):
        self.__IS = [IS]
        return self
    def addIS(self, IS = None):
        if self.__IS == None:            self.__IS =  []
        self.__IS +=  [IS]
        return self
    def removeIS(self, IS):
        self.__IS = [x for x in self.__IS if x not in IS]
        return self.__IS
    def getIS(self, IS = None):
        return self.__IS
    def IS_changed(self, IS = None):
        return self.__IS
    def toXML(self):
        str = ''
        str += '<Transform'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__center is not None:
            if isinstance(self.__center, six.string_types):
                str += ' center="'+self.__center+'"'
            else:
                str += ' center="'+self.__center[0]+'"'
        if self.__rotation is not None:
            if isinstance(self.__rotation, six.string_types):
                str += ' rotation="'+self.__rotation+'"'
            else:
                str += ' rotation="'+self.__rotation[0]+'"'
        if self.__scale is not None:
            if isinstance(self.__scale, six.string_types):
                str += ' scale="'+self.__scale+'"'
            else:
                str += ' scale="'+self.__scale[0]+'"'
        if self.__scaleOrientation is not None:
            if isinstance(self.__scaleOrientation, six.string_types):
                str += ' scaleOrientation="'+self.__scaleOrientation+'"'
            else:
                str += ' scaleOrientation="'+self.__scaleOrientation[0]+'"'
        if self.__translation is not None:
            if isinstance(self.__translation, six.string_types):
                str += ' translation="'+self.__translation+'"'
            else:
                str += ' translation="'+self.__translation[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '</Transform>'
        return str


class TransformSensor(X3DEnvironmentalSensorNode):
    def __init__(self, **kwargs):
        super(TransformSensor, self).__init__(**kwargs)
        center  = kwargs.pop("center", [0, 0, 0])
        self.__center = center
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        enterTime  = kwargs.pop("enterTime", None)
        self.__enterTime = enterTime
        exitTime  = kwargs.pop("exitTime", None)
        self.__exitTime = exitTime
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        orientation_changed  = kwargs.pop("orientation_changed", None)
        self.__orientation_changed = orientation_changed
        position_changed  = kwargs.pop("position_changed", None)
        self.__position_changed = position_changed
        size  = kwargs.pop("size", [0, 0, 0])
        if size == None or len(size) <= 0 or min(size)  <  0:
            return None
        self.__size = size
        targetObject  = kwargs.pop("targetObject", None)
        self.__targetObject = targetObject
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def center(self):
        return self.__center
    @center.setter
    def center(self, value = [0, 0, 0]):
        self.__center = [value]
    def setCenter(self, center = [0, 0, 0]):
        self.__center = [center]
        return self
    def addCenter(self, center = [0, 0, 0]):
        if self.__center == None:            self.__center =  []
        self.__center +=  [center]
        return self
    def removeCenter(self, center):
        self.__center = [x for x in self.__center if x not in center]
        return self.__center
    def getCenter(self, center = [0, 0, 0]):
        return self.__center
    def center_changed(self, center = [0, 0, 0]):
        return self.__center
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    def removeEnterTime(self, enterTime):
        self.__enterTime = [x for x in self.__enterTime if x not in enterTime]
        return self.__enterTime
    def getEnterTime(self, enterTime = None):
        return self.__enterTime
    def enterTime_changed(self, enterTime = None):
        return self.__enterTime
    def removeExitTime(self, exitTime):
        self.__exitTime = [x for x in self.__exitTime if x not in exitTime]
        return self.__exitTime
    def getExitTime(self, exitTime = None):
        return self.__exitTime
    def exitTime_changed(self, exitTime = None):
        return self.__exitTime
    def isActive(self, Active = None):
        return self.__Active
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    def removeorientation_changed(self, orientation_changed):
        self.__orientation_changed = [x for x in self.__orientation_changed if x not in orientation_changed]
        return self.__orientation_changed
    def getorientation_changed(self, orientation_changed = None):
        return self.__orientation_changed
    def orientation_changed_changed(self, orientation_changed = None):
        return self.__orientation_changed
    def removeposition_changed(self, position_changed):
        self.__position_changed = [x for x in self.__position_changed if x not in position_changed]
        return self.__position_changed
    def getposition_changed(self, position_changed = None):
        return self.__position_changed
    def position_changed_changed(self, position_changed = None):
        return self.__position_changed
    @property
    def targetObject(self):
        return self.__targetObject
    @targetObject.setter
    def targetObject(self, value = None):
        self.__targetObject = [value]
    def setTargetObject(self, targetObject = None):
        self.__targetObject = [targetObject]
        return self
    def addTargetObject(self, targetObject = None):
        if self.__targetObject == None:            self.__targetObject =  []
        self.__targetObject +=  [targetObject]
        return self
    def removeTargetObject(self, targetObject):
        self.__targetObject = [x for x in self.__targetObject if x not in targetObject]
        return self.__targetObject
    def getTargetObject(self, targetObject = None):
        return self.__targetObject
    def targetObject_changed(self, targetObject = None):
        return self.__targetObject
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<TransformSensor'
        if self.__center is not None:
            if isinstance(self.__center, six.string_types):
                str += ' center="'+self.__center+'"'
            else:
                str += ' center="'+self.__center[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__enterTime is not None:
            if isinstance(self.__enterTime, six.string_types):
                str += ' enterTime="'+self.__enterTime+'"'
            else:
                str += ' enterTime="'+self.__enterTime[0]+'"'
        if self.__exitTime is not None:
            if isinstance(self.__exitTime, six.string_types):
                str += ' exitTime="'+self.__exitTime+'"'
            else:
                str += ' exitTime="'+self.__exitTime[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__orientation_changed is not None:
            if isinstance(self.__orientation_changed, six.string_types):
                str += ' orientation_changed="'+self.__orientation_changed+'"'
            else:
                str += ' orientation_changed="'+self.__orientation_changed[0]+'"'
        if self.__position_changed is not None:
            if isinstance(self.__position_changed, six.string_types):
                str += ' position_changed="'+self.__position_changed+'"'
            else:
                str += ' position_changed="'+self.__position_changed[0]+'"'
        if self.__size is not None:
            if isinstance(self.__size, six.string_types):
                str += ' size="'+self.__size+'"'
            else:
                str += ' size="'+self.__size[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<targetObject'
        if self.__targetObject is not None:
           for s in self.__targetObject:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__targetObject is not None:
           for s in self.__targetObject:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</targetObject>'
        str += '</TransformSensor>'
        return str


class TransmitterPdu(X3DBoundedObject, X3DNetworkSensorNode):
    def __init__(self, **kwargs):
        super(TransmitterPdu, self).__init__(**kwargs)
        address  = kwargs.pop("address", "localhost")
        self.__address = address
        antennaLocation  = kwargs.pop("antennaLocation", [0, 0, 0])
        self.__antennaLocation = antennaLocation
        antennaPatternLength  = kwargs.pop("antennaPatternLength", 0)
        self.__antennaPatternLength = antennaPatternLength
        antennaPatternType  = kwargs.pop("antennaPatternType", 0)
        self.__antennaPatternType = antennaPatternType
        applicationID  = kwargs.pop("applicationID", 0)
        self.__applicationID = applicationID
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        cryptoKeyID  = kwargs.pop("cryptoKeyID", 0)
        self.__cryptoKeyID = cryptoKeyID
        cryptoSystem  = kwargs.pop("cryptoSystem", 0)
        self.__cryptoSystem = cryptoSystem
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        entityID  = kwargs.pop("entityID", 0)
        self.__entityID = entityID
        frequency  = kwargs.pop("frequency", 0)
        self.__frequency = frequency
        geoCoords  = kwargs.pop("geoCoords", [0, 0, 0])
        self.__geoCoords = geoCoords
        geoSystem  = kwargs.pop("geoSystem", ["GD", "WE"])
        self.__geoSystem = geoSystem
        inputSource  = kwargs.pop("inputSource", 0)
        self.__inputSource = inputSource
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        NetworkReader  = kwargs.pop("NetworkReader", None)
        self.__NetworkReader = NetworkReader
        NetworkWriter  = kwargs.pop("NetworkWriter", None)
        self.__NetworkWriter = NetworkWriter
        RtpHeaderHeard  = kwargs.pop("RtpHeaderHeard", None)
        self.__RtpHeaderHeard = RtpHeaderHeard
        StandAlone  = kwargs.pop("StandAlone", None)
        self.__StandAlone = StandAlone
        lengthOfModulationParameters  = kwargs.pop("lengthOfModulationParameters", 0)
        self.__lengthOfModulationParameters = lengthOfModulationParameters
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        modulationTypeDetail  = kwargs.pop("modulationTypeDetail", 0)
        self.__modulationTypeDetail = modulationTypeDetail
        modulationTypeMajor  = kwargs.pop("modulationTypeMajor", 0)
        self.__modulationTypeMajor = modulationTypeMajor
        modulationTypeSpreadSpectrum  = kwargs.pop("modulationTypeSpreadSpectrum", 0)
        self.__modulationTypeSpreadSpectrum = modulationTypeSpreadSpectrum
        modulationTypeSystem  = kwargs.pop("modulationTypeSystem", 0)
        self.__modulationTypeSystem = modulationTypeSystem
        multicastRelayHost  = kwargs.pop("multicastRelayHost", None)
        self.__multicastRelayHost = multicastRelayHost
        multicastRelayPort  = kwargs.pop("multicastRelayPort", 0)
        self.__multicastRelayPort = multicastRelayPort
        networkMode  = kwargs.pop("networkMode", "standAlone")
        if 'standAlone' == networkMode:
            pass
        elif 'networkReader' == networkMode:
            pass
        elif 'networkWriter' == networkMode:
            pass
        else:
            return None
        self.__networkMode = networkMode
        port  = kwargs.pop("port", 0)
        self.__port = port
        power  = kwargs.pop("power", 0.0)
        self.__power = power
        radioEntityTypeCategory  = kwargs.pop("radioEntityTypeCategory", 0)
        self.__radioEntityTypeCategory = radioEntityTypeCategory
        radioEntityTypeCountry  = kwargs.pop("radioEntityTypeCountry", 0)
        self.__radioEntityTypeCountry = radioEntityTypeCountry
        radioEntityTypeDomain  = kwargs.pop("radioEntityTypeDomain", 0)
        self.__radioEntityTypeDomain = radioEntityTypeDomain
        radioEntityTypeKind  = kwargs.pop("radioEntityTypeKind", 0)
        self.__radioEntityTypeKind = radioEntityTypeKind
        radioEntityTypeNomenclature  = kwargs.pop("radioEntityTypeNomenclature", 0)
        self.__radioEntityTypeNomenclature = radioEntityTypeNomenclature
        radioEntityTypeNomenclatureVersion  = kwargs.pop("radioEntityTypeNomenclatureVersion", 0)
        self.__radioEntityTypeNomenclatureVersion = radioEntityTypeNomenclatureVersion
        radioID  = kwargs.pop("radioID", 0)
        self.__radioID = radioID
        readInterval  = kwargs.pop("readInterval", 0.1)
        if readInterval == None or readInterval  <  0:
            return None
        self.__readInterval = readInterval
        relativeAntennaLocation  = kwargs.pop("relativeAntennaLocation", [0, 0, 0])
        self.__relativeAntennaLocation = relativeAntennaLocation
        rtpHeaderExpected  = kwargs.pop("rtpHeaderExpected", False)
        self.__rtpHeaderExpected = rtpHeaderExpected
        siteID  = kwargs.pop("siteID", 0)
        self.__siteID = siteID
        timestamp  = kwargs.pop("timestamp", None)
        if timestamp == None or timestamp  <  0:
            return None
        self.__timestamp = timestamp
        transmitFrequencyBandwidth  = kwargs.pop("transmitFrequencyBandwidth", 0)
        self.__transmitFrequencyBandwidth = transmitFrequencyBandwidth
        transmitState  = kwargs.pop("transmitState", 0)
        self.__transmitState = transmitState
        whichGeometry  = kwargs.pop("whichGeometry", 1)
        self.__whichGeometry = whichGeometry
        writeInterval  = kwargs.pop("writeInterval", 1.0)
        if writeInterval == None or writeInterval  <  0:
            return None
        self.__writeInterval = writeInterval
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def address(self):
        return self.__address
    @address.setter
    def address(self, value = "localhost"):
        self.__address = [value]
    def address(self, address = "localhost"):
        if self.__address == None:            self.__address =  []
        self.__address +=  [address]
        return self
    def removeAddress(self, address):
        self.__address = [x for x in self.__address if x not in address]
        return self.__address
    def getAddress(self, address = "localhost"):
        return self.__address
    def address_changed(self, address = "localhost"):
        return self.__address
    @property
    def antennaLocation(self):
        return self.__antennaLocation
    @antennaLocation.setter
    def antennaLocation(self, value = [0, 0, 0]):
        self.__antennaLocation = [value]
    def setAntennaLocation(self, antennaLocation = [0, 0, 0]):
        self.__antennaLocation = [antennaLocation]
        return self
    def addAntennaLocation(self, antennaLocation = [0, 0, 0]):
        if self.__antennaLocation == None:            self.__antennaLocation =  []
        self.__antennaLocation +=  [antennaLocation]
        return self
    def removeAntennaLocation(self, antennaLocation):
        self.__antennaLocation = [x for x in self.__antennaLocation if x not in antennaLocation]
        return self.__antennaLocation
    def getAntennaLocation(self, antennaLocation = [0, 0, 0]):
        return self.__antennaLocation
    def antennaLocation_changed(self, antennaLocation = [0, 0, 0]):
        return self.__antennaLocation
    @property
    def antennaPatternLength(self):
        return self.__antennaPatternLength
    @antennaPatternLength.setter
    def antennaPatternLength(self, value = 0):
        self.__antennaPatternLength = [value]
    def setAntennaPatternLength(self, antennaPatternLength = 0):
        self.__antennaPatternLength = [antennaPatternLength]
        return self
    def addAntennaPatternLength(self, antennaPatternLength = 0):
        if self.__antennaPatternLength == None:            self.__antennaPatternLength =  []
        self.__antennaPatternLength +=  [antennaPatternLength]
        return self
    def removeAntennaPatternLength(self, antennaPatternLength):
        self.__antennaPatternLength = [x for x in self.__antennaPatternLength if x not in antennaPatternLength]
        return self.__antennaPatternLength
    def getAntennaPatternLength(self, antennaPatternLength = 0):
        return self.__antennaPatternLength
    def antennaPatternLength_changed(self, antennaPatternLength = 0):
        return self.__antennaPatternLength
    @property
    def antennaPatternType(self):
        return self.__antennaPatternType
    @antennaPatternType.setter
    def antennaPatternType(self, value = 0):
        self.__antennaPatternType = [value]
    def setAntennaPatternType(self, antennaPatternType = 0):
        self.__antennaPatternType = [antennaPatternType]
        return self
    def addAntennaPatternType(self, antennaPatternType = 0):
        if self.__antennaPatternType == None:            self.__antennaPatternType =  []
        self.__antennaPatternType +=  [antennaPatternType]
        return self
    def removeAntennaPatternType(self, antennaPatternType):
        self.__antennaPatternType = [x for x in self.__antennaPatternType if x not in antennaPatternType]
        return self.__antennaPatternType
    def getAntennaPatternType(self, antennaPatternType = 0):
        return self.__antennaPatternType
    def antennaPatternType_changed(self, antennaPatternType = 0):
        return self.__antennaPatternType
    @property
    def applicationID(self):
        return self.__applicationID
    @applicationID.setter
    def applicationID(self, value = 0):
        self.__applicationID = [value]
    def setApplicationID(self, applicationID = 0):
        self.__applicationID = [applicationID]
        return self
    def addApplicationID(self, applicationID = 0):
        if self.__applicationID == None:            self.__applicationID =  []
        self.__applicationID +=  [applicationID]
        return self
    def removeApplicationID(self, applicationID):
        self.__applicationID = [x for x in self.__applicationID if x not in applicationID]
        return self.__applicationID
    def getApplicationID(self, applicationID = 0):
        return self.__applicationID
    def applicationID_changed(self, applicationID = 0):
        return self.__applicationID
    @property
    def cryptoKeyID(self):
        return self.__cryptoKeyID
    @cryptoKeyID.setter
    def cryptoKeyID(self, value = 0):
        self.__cryptoKeyID = [value]
    def setCryptoKeyID(self, cryptoKeyID = 0):
        self.__cryptoKeyID = [cryptoKeyID]
        return self
    def addCryptoKeyID(self, cryptoKeyID = 0):
        if self.__cryptoKeyID == None:            self.__cryptoKeyID =  []
        self.__cryptoKeyID +=  [cryptoKeyID]
        return self
    def removeCryptoKeyID(self, cryptoKeyID):
        self.__cryptoKeyID = [x for x in self.__cryptoKeyID if x not in cryptoKeyID]
        return self.__cryptoKeyID
    def getCryptoKeyID(self, cryptoKeyID = 0):
        return self.__cryptoKeyID
    def cryptoKeyID_changed(self, cryptoKeyID = 0):
        return self.__cryptoKeyID
    @property
    def cryptoSystem(self):
        return self.__cryptoSystem
    @cryptoSystem.setter
    def cryptoSystem(self, value = 0):
        self.__cryptoSystem = [value]
    def setCryptoSystem(self, cryptoSystem = 0):
        self.__cryptoSystem = [cryptoSystem]
        return self
    def addCryptoSystem(self, cryptoSystem = 0):
        if self.__cryptoSystem == None:            self.__cryptoSystem =  []
        self.__cryptoSystem +=  [cryptoSystem]
        return self
    def removeCryptoSystem(self, cryptoSystem):
        self.__cryptoSystem = [x for x in self.__cryptoSystem if x not in cryptoSystem]
        return self.__cryptoSystem
    def getCryptoSystem(self, cryptoSystem = 0):
        return self.__cryptoSystem
    def cryptoSystem_changed(self, cryptoSystem = 0):
        return self.__cryptoSystem
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def entityID(self):
        return self.__entityID
    @entityID.setter
    def entityID(self, value = 0):
        self.__entityID = [value]
    def setEntityID(self, entityID = 0):
        self.__entityID = [entityID]
        return self
    def addEntityID(self, entityID = 0):
        if self.__entityID == None:            self.__entityID =  []
        self.__entityID +=  [entityID]
        return self
    def removeEntityID(self, entityID):
        self.__entityID = [x for x in self.__entityID if x not in entityID]
        return self.__entityID
    def getEntityID(self, entityID = 0):
        return self.__entityID
    def entityID_changed(self, entityID = 0):
        return self.__entityID
    @property
    def frequency(self):
        return self.__frequency
    @frequency.setter
    def frequency(self, value = 0):
        self.__frequency = [value]
    def setFrequency(self, frequency = 0):
        self.__frequency = [frequency]
        return self
    def addFrequency(self, frequency = 0):
        if self.__frequency == None:            self.__frequency =  []
        self.__frequency +=  [frequency]
        return self
    def removeFrequency(self, frequency):
        self.__frequency = [x for x in self.__frequency if x not in frequency]
        return self.__frequency
    def getFrequency(self, frequency = 0):
        return self.__frequency
    def frequency_changed(self, frequency = 0):
        return self.__frequency
    @property
    def geoCoords(self):
        return self.__geoCoords
    @geoCoords.setter
    def geoCoords(self, value = [0, 0, 0]):
        self.__geoCoords = [value]
    def setGeoCoords(self, geoCoords = [0, 0, 0]):
        self.__geoCoords = [geoCoords]
        return self
    def addGeoCoords(self, geoCoords = [0, 0, 0]):
        if self.__geoCoords == None:            self.__geoCoords =  []
        self.__geoCoords +=  [geoCoords]
        return self
    def removeGeoCoords(self, geoCoords):
        self.__geoCoords = [x for x in self.__geoCoords if x not in geoCoords]
        return self.__geoCoords
    def getGeoCoords(self, geoCoords = [0, 0, 0]):
        return self.__geoCoords
    def geoCoords_changed(self, geoCoords = [0, 0, 0]):
        return self.__geoCoords
    @property
    def inputSource(self):
        return self.__inputSource
    @inputSource.setter
    def inputSource(self, value = 0):
        self.__inputSource = [value]
    def setInputSource(self, inputSource = 0):
        self.__inputSource = [inputSource]
        return self
    def addInputSource(self, inputSource = 0):
        if self.__inputSource == None:            self.__inputSource =  []
        self.__inputSource +=  [inputSource]
        return self
    def removeInputSource(self, inputSource):
        self.__inputSource = [x for x in self.__inputSource if x not in inputSource]
        return self.__inputSource
    def getInputSource(self, inputSource = 0):
        return self.__inputSource
    def inputSource_changed(self, inputSource = 0):
        return self.__inputSource
    def isActive(self, Active = None):
        return self.__Active
    def isNetworkReader(self, NetworkReader = None):
        return self.__NetworkReader
    def isNetworkWriter(self, NetworkWriter = None):
        return self.__NetworkWriter
    def isRtpHeaderHeard(self, RtpHeaderHeard = None):
        return self.__RtpHeaderHeard
    def isStandAlone(self, StandAlone = None):
        return self.__StandAlone
    @property
    def lengthOfModulationParameters(self):
        return self.__lengthOfModulationParameters
    @lengthOfModulationParameters.setter
    def lengthOfModulationParameters(self, value = 0):
        self.__lengthOfModulationParameters = [value]
    def setLengthOfModulationParameters(self, lengthOfModulationParameters = 0):
        self.__lengthOfModulationParameters = [lengthOfModulationParameters]
        return self
    def addLengthOfModulationParameters(self, lengthOfModulationParameters = 0):
        if self.__lengthOfModulationParameters == None:            self.__lengthOfModulationParameters =  []
        self.__lengthOfModulationParameters +=  [lengthOfModulationParameters]
        return self
    def removeLengthOfModulationParameters(self, lengthOfModulationParameters):
        self.__lengthOfModulationParameters = [x for x in self.__lengthOfModulationParameters if x not in lengthOfModulationParameters]
        return self.__lengthOfModulationParameters
    def getLengthOfModulationParameters(self, lengthOfModulationParameters = 0):
        return self.__lengthOfModulationParameters
    def lengthOfModulationParameters_changed(self, lengthOfModulationParameters = 0):
        return self.__lengthOfModulationParameters
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def modulationTypeDetail(self):
        return self.__modulationTypeDetail
    @modulationTypeDetail.setter
    def modulationTypeDetail(self, value = 0):
        self.__modulationTypeDetail = [value]
    def setModulationTypeDetail(self, modulationTypeDetail = 0):
        self.__modulationTypeDetail = [modulationTypeDetail]
        return self
    def addModulationTypeDetail(self, modulationTypeDetail = 0):
        if self.__modulationTypeDetail == None:            self.__modulationTypeDetail =  []
        self.__modulationTypeDetail +=  [modulationTypeDetail]
        return self
    def removeModulationTypeDetail(self, modulationTypeDetail):
        self.__modulationTypeDetail = [x for x in self.__modulationTypeDetail if x not in modulationTypeDetail]
        return self.__modulationTypeDetail
    def getModulationTypeDetail(self, modulationTypeDetail = 0):
        return self.__modulationTypeDetail
    def modulationTypeDetail_changed(self, modulationTypeDetail = 0):
        return self.__modulationTypeDetail
    @property
    def modulationTypeMajor(self):
        return self.__modulationTypeMajor
    @modulationTypeMajor.setter
    def modulationTypeMajor(self, value = 0):
        self.__modulationTypeMajor = [value]
    def setModulationTypeMajor(self, modulationTypeMajor = 0):
        self.__modulationTypeMajor = [modulationTypeMajor]
        return self
    def addModulationTypeMajor(self, modulationTypeMajor = 0):
        if self.__modulationTypeMajor == None:            self.__modulationTypeMajor =  []
        self.__modulationTypeMajor +=  [modulationTypeMajor]
        return self
    def removeModulationTypeMajor(self, modulationTypeMajor):
        self.__modulationTypeMajor = [x for x in self.__modulationTypeMajor if x not in modulationTypeMajor]
        return self.__modulationTypeMajor
    def getModulationTypeMajor(self, modulationTypeMajor = 0):
        return self.__modulationTypeMajor
    def modulationTypeMajor_changed(self, modulationTypeMajor = 0):
        return self.__modulationTypeMajor
    @property
    def modulationTypeSpreadSpectrum(self):
        return self.__modulationTypeSpreadSpectrum
    @modulationTypeSpreadSpectrum.setter
    def modulationTypeSpreadSpectrum(self, value = 0):
        self.__modulationTypeSpreadSpectrum = [value]
    def setModulationTypeSpreadSpectrum(self, modulationTypeSpreadSpectrum = 0):
        self.__modulationTypeSpreadSpectrum = [modulationTypeSpreadSpectrum]
        return self
    def addModulationTypeSpreadSpectrum(self, modulationTypeSpreadSpectrum = 0):
        if self.__modulationTypeSpreadSpectrum == None:            self.__modulationTypeSpreadSpectrum =  []
        self.__modulationTypeSpreadSpectrum +=  [modulationTypeSpreadSpectrum]
        return self
    def removeModulationTypeSpreadSpectrum(self, modulationTypeSpreadSpectrum):
        self.__modulationTypeSpreadSpectrum = [x for x in self.__modulationTypeSpreadSpectrum if x not in modulationTypeSpreadSpectrum]
        return self.__modulationTypeSpreadSpectrum
    def getModulationTypeSpreadSpectrum(self, modulationTypeSpreadSpectrum = 0):
        return self.__modulationTypeSpreadSpectrum
    def modulationTypeSpreadSpectrum_changed(self, modulationTypeSpreadSpectrum = 0):
        return self.__modulationTypeSpreadSpectrum
    @property
    def modulationTypeSystem(self):
        return self.__modulationTypeSystem
    @modulationTypeSystem.setter
    def modulationTypeSystem(self, value = 0):
        self.__modulationTypeSystem = [value]
    def setModulationTypeSystem(self, modulationTypeSystem = 0):
        self.__modulationTypeSystem = [modulationTypeSystem]
        return self
    def addModulationTypeSystem(self, modulationTypeSystem = 0):
        if self.__modulationTypeSystem == None:            self.__modulationTypeSystem =  []
        self.__modulationTypeSystem +=  [modulationTypeSystem]
        return self
    def removeModulationTypeSystem(self, modulationTypeSystem):
        self.__modulationTypeSystem = [x for x in self.__modulationTypeSystem if x not in modulationTypeSystem]
        return self.__modulationTypeSystem
    def getModulationTypeSystem(self, modulationTypeSystem = 0):
        return self.__modulationTypeSystem
    def modulationTypeSystem_changed(self, modulationTypeSystem = 0):
        return self.__modulationTypeSystem
    @property
    def multicastRelayHost(self):
        return self.__multicastRelayHost
    @multicastRelayHost.setter
    def multicastRelayHost(self, value = None):
        self.__multicastRelayHost = [value]
    def setMulticastRelayHost(self, multicastRelayHost = None):
        self.__multicastRelayHost = [multicastRelayHost]
        return self
    def addMulticastRelayHost(self, multicastRelayHost = None):
        if self.__multicastRelayHost == None:            self.__multicastRelayHost =  []
        self.__multicastRelayHost +=  [multicastRelayHost]
        return self
    def removeMulticastRelayHost(self, multicastRelayHost):
        self.__multicastRelayHost = [x for x in self.__multicastRelayHost if x not in multicastRelayHost]
        return self.__multicastRelayHost
    def getMulticastRelayHost(self, multicastRelayHost = None):
        return self.__multicastRelayHost
    def multicastRelayHost_changed(self, multicastRelayHost = None):
        return self.__multicastRelayHost
    @property
    def multicastRelayPort(self):
        return self.__multicastRelayPort
    @multicastRelayPort.setter
    def multicastRelayPort(self, value = 0):
        self.__multicastRelayPort = [value]
    def setMulticastRelayPort(self, multicastRelayPort = 0):
        self.__multicastRelayPort = [multicastRelayPort]
        return self
    def addMulticastRelayPort(self, multicastRelayPort = 0):
        if self.__multicastRelayPort == None:            self.__multicastRelayPort =  []
        self.__multicastRelayPort +=  [multicastRelayPort]
        return self
    def removeMulticastRelayPort(self, multicastRelayPort):
        self.__multicastRelayPort = [x for x in self.__multicastRelayPort if x not in multicastRelayPort]
        return self.__multicastRelayPort
    def getMulticastRelayPort(self, multicastRelayPort = 0):
        return self.__multicastRelayPort
    def multicastRelayPort_changed(self, multicastRelayPort = 0):
        return self.__multicastRelayPort
    @property
    def networkMode(self):
        return self.__networkMode
    @networkMode.setter
    def networkMode(self, value = "standAlone"):
        if 'standAlone' == value:
            pass
        elif 'networkReader' == value:
            pass
        elif 'networkWriter' == value:
            pass
        else:
            return None
        self.__networkMode = [value]
    def setNetworkMode(self, networkMode = "standAlone"):
        if 'standAlone' == networkMode:
            pass
        elif 'networkReader' == networkMode:
            pass
        elif 'networkWriter' == networkMode:
            pass
        else:
            return None
        self.__networkMode = [networkMode]
        return self
    def addNetworkMode(self, networkMode = "standAlone"):
        if 'standAlone' == networkMode:
            pass
        elif 'networkReader' == networkMode:
            pass
        elif 'networkWriter' == networkMode:
            pass
        else:
            return None
        if self.__networkMode == None:            self.__networkMode =  []
        self.__networkMode +=  [networkMode]
        return self
    def removeNetworkMode(self, networkMode):
        self.__networkMode = [x for x in self.__networkMode if x not in networkMode]
        return self.__networkMode
    def getNetworkMode(self, networkMode = "standAlone"):
        return self.__networkMode
    def networkMode_changed(self, networkMode = "standAlone"):
        return self.__networkMode
    @property
    def port(self):
        return self.__port
    @port.setter
    def port(self, value = 0):
        self.__port = [value]
    def setPort(self, port = 0):
        self.__port = [port]
        return self
    def addPort(self, port = 0):
        if self.__port == None:            self.__port =  []
        self.__port +=  [port]
        return self
    def removePort(self, port):
        self.__port = [x for x in self.__port if x not in port]
        return self.__port
    def getPort(self, port = 0):
        return self.__port
    def port_changed(self, port = 0):
        return self.__port
    @property
    def power(self):
        return self.__power
    @power.setter
    def power(self, value = 0.0):
        self.__power = [value]
    def setPower(self, power = 0.0):
        self.__power = [power]
        return self
    def addPower(self, power = 0.0):
        if self.__power == None:            self.__power =  []
        self.__power +=  [power]
        return self
    def removePower(self, power):
        self.__power = [x for x in self.__power if x not in power]
        return self.__power
    def getPower(self, power = 0.0):
        return self.__power
    def power_changed(self, power = 0.0):
        return self.__power
    @property
    def radioEntityTypeCategory(self):
        return self.__radioEntityTypeCategory
    @radioEntityTypeCategory.setter
    def radioEntityTypeCategory(self, value = 0):
        self.__radioEntityTypeCategory = [value]
    def setRadioEntityTypeCategory(self, radioEntityTypeCategory = 0):
        self.__radioEntityTypeCategory = [radioEntityTypeCategory]
        return self
    def addRadioEntityTypeCategory(self, radioEntityTypeCategory = 0):
        if self.__radioEntityTypeCategory == None:            self.__radioEntityTypeCategory =  []
        self.__radioEntityTypeCategory +=  [radioEntityTypeCategory]
        return self
    def removeRadioEntityTypeCategory(self, radioEntityTypeCategory):
        self.__radioEntityTypeCategory = [x for x in self.__radioEntityTypeCategory if x not in radioEntityTypeCategory]
        return self.__radioEntityTypeCategory
    def getRadioEntityTypeCategory(self, radioEntityTypeCategory = 0):
        return self.__radioEntityTypeCategory
    def radioEntityTypeCategory_changed(self, radioEntityTypeCategory = 0):
        return self.__radioEntityTypeCategory
    @property
    def radioEntityTypeCountry(self):
        return self.__radioEntityTypeCountry
    @radioEntityTypeCountry.setter
    def radioEntityTypeCountry(self, value = 0):
        self.__radioEntityTypeCountry = [value]
    def setRadioEntityTypeCountry(self, radioEntityTypeCountry = 0):
        self.__radioEntityTypeCountry = [radioEntityTypeCountry]
        return self
    def addRadioEntityTypeCountry(self, radioEntityTypeCountry = 0):
        if self.__radioEntityTypeCountry == None:            self.__radioEntityTypeCountry =  []
        self.__radioEntityTypeCountry +=  [radioEntityTypeCountry]
        return self
    def removeRadioEntityTypeCountry(self, radioEntityTypeCountry):
        self.__radioEntityTypeCountry = [x for x in self.__radioEntityTypeCountry if x not in radioEntityTypeCountry]
        return self.__radioEntityTypeCountry
    def getRadioEntityTypeCountry(self, radioEntityTypeCountry = 0):
        return self.__radioEntityTypeCountry
    def radioEntityTypeCountry_changed(self, radioEntityTypeCountry = 0):
        return self.__radioEntityTypeCountry
    @property
    def radioEntityTypeDomain(self):
        return self.__radioEntityTypeDomain
    @radioEntityTypeDomain.setter
    def radioEntityTypeDomain(self, value = 0):
        self.__radioEntityTypeDomain = [value]
    def setRadioEntityTypeDomain(self, radioEntityTypeDomain = 0):
        self.__radioEntityTypeDomain = [radioEntityTypeDomain]
        return self
    def addRadioEntityTypeDomain(self, radioEntityTypeDomain = 0):
        if self.__radioEntityTypeDomain == None:            self.__radioEntityTypeDomain =  []
        self.__radioEntityTypeDomain +=  [radioEntityTypeDomain]
        return self
    def removeRadioEntityTypeDomain(self, radioEntityTypeDomain):
        self.__radioEntityTypeDomain = [x for x in self.__radioEntityTypeDomain if x not in radioEntityTypeDomain]
        return self.__radioEntityTypeDomain
    def getRadioEntityTypeDomain(self, radioEntityTypeDomain = 0):
        return self.__radioEntityTypeDomain
    def radioEntityTypeDomain_changed(self, radioEntityTypeDomain = 0):
        return self.__radioEntityTypeDomain
    @property
    def radioEntityTypeKind(self):
        return self.__radioEntityTypeKind
    @radioEntityTypeKind.setter
    def radioEntityTypeKind(self, value = 0):
        self.__radioEntityTypeKind = [value]
    def setRadioEntityTypeKind(self, radioEntityTypeKind = 0):
        self.__radioEntityTypeKind = [radioEntityTypeKind]
        return self
    def addRadioEntityTypeKind(self, radioEntityTypeKind = 0):
        if self.__radioEntityTypeKind == None:            self.__radioEntityTypeKind =  []
        self.__radioEntityTypeKind +=  [radioEntityTypeKind]
        return self
    def removeRadioEntityTypeKind(self, radioEntityTypeKind):
        self.__radioEntityTypeKind = [x for x in self.__radioEntityTypeKind if x not in radioEntityTypeKind]
        return self.__radioEntityTypeKind
    def getRadioEntityTypeKind(self, radioEntityTypeKind = 0):
        return self.__radioEntityTypeKind
    def radioEntityTypeKind_changed(self, radioEntityTypeKind = 0):
        return self.__radioEntityTypeKind
    @property
    def radioEntityTypeNomenclature(self):
        return self.__radioEntityTypeNomenclature
    @radioEntityTypeNomenclature.setter
    def radioEntityTypeNomenclature(self, value = 0):
        self.__radioEntityTypeNomenclature = [value]
    def setRadioEntityTypeNomenclature(self, radioEntityTypeNomenclature = 0):
        self.__radioEntityTypeNomenclature = [radioEntityTypeNomenclature]
        return self
    def addRadioEntityTypeNomenclature(self, radioEntityTypeNomenclature = 0):
        if self.__radioEntityTypeNomenclature == None:            self.__radioEntityTypeNomenclature =  []
        self.__radioEntityTypeNomenclature +=  [radioEntityTypeNomenclature]
        return self
    def removeRadioEntityTypeNomenclature(self, radioEntityTypeNomenclature):
        self.__radioEntityTypeNomenclature = [x for x in self.__radioEntityTypeNomenclature if x not in radioEntityTypeNomenclature]
        return self.__radioEntityTypeNomenclature
    def getRadioEntityTypeNomenclature(self, radioEntityTypeNomenclature = 0):
        return self.__radioEntityTypeNomenclature
    def radioEntityTypeNomenclature_changed(self, radioEntityTypeNomenclature = 0):
        return self.__radioEntityTypeNomenclature
    @property
    def radioEntityTypeNomenclatureVersion(self):
        return self.__radioEntityTypeNomenclatureVersion
    @radioEntityTypeNomenclatureVersion.setter
    def radioEntityTypeNomenclatureVersion(self, value = 0):
        self.__radioEntityTypeNomenclatureVersion = [value]
    def setRadioEntityTypeNomenclatureVersion(self, radioEntityTypeNomenclatureVersion = 0):
        self.__radioEntityTypeNomenclatureVersion = [radioEntityTypeNomenclatureVersion]
        return self
    def addRadioEntityTypeNomenclatureVersion(self, radioEntityTypeNomenclatureVersion = 0):
        if self.__radioEntityTypeNomenclatureVersion == None:            self.__radioEntityTypeNomenclatureVersion =  []
        self.__radioEntityTypeNomenclatureVersion +=  [radioEntityTypeNomenclatureVersion]
        return self
    def removeRadioEntityTypeNomenclatureVersion(self, radioEntityTypeNomenclatureVersion):
        self.__radioEntityTypeNomenclatureVersion = [x for x in self.__radioEntityTypeNomenclatureVersion if x not in radioEntityTypeNomenclatureVersion]
        return self.__radioEntityTypeNomenclatureVersion
    def getRadioEntityTypeNomenclatureVersion(self, radioEntityTypeNomenclatureVersion = 0):
        return self.__radioEntityTypeNomenclatureVersion
    def radioEntityTypeNomenclatureVersion_changed(self, radioEntityTypeNomenclatureVersion = 0):
        return self.__radioEntityTypeNomenclatureVersion
    @property
    def radioID(self):
        return self.__radioID
    @radioID.setter
    def radioID(self, value = 0):
        self.__radioID = [value]
    def setRadioID(self, radioID = 0):
        self.__radioID = [radioID]
        return self
    def addRadioID(self, radioID = 0):
        if self.__radioID == None:            self.__radioID =  []
        self.__radioID +=  [radioID]
        return self
    def removeRadioID(self, radioID):
        self.__radioID = [x for x in self.__radioID if x not in radioID]
        return self.__radioID
    def getRadioID(self, radioID = 0):
        return self.__radioID
    def radioID_changed(self, radioID = 0):
        return self.__radioID
    @property
    def readInterval(self):
        return self.__readInterval
    @readInterval.setter
    def readInterval(self, value = 0.1):
        if value == None or value  <  0:
            return None
        self.__readInterval = [value]
    def setReadInterval(self, readInterval = 0.1):
        if readInterval == None or readInterval  <  0:
            return None
        self.__readInterval = [readInterval]
        return self
    def addReadInterval(self, readInterval = 0.1):
        if readInterval == None or readInterval  <  0:
            return None
        if self.__readInterval == None:            self.__readInterval =  []
        self.__readInterval +=  [readInterval]
        return self
    def removeReadInterval(self, readInterval):
        self.__readInterval = [x for x in self.__readInterval if x not in readInterval]
        return self.__readInterval
    def getReadInterval(self, readInterval = 0.1):
        return self.__readInterval
    def readInterval_changed(self, readInterval = 0.1):
        return self.__readInterval
    @property
    def relativeAntennaLocation(self):
        return self.__relativeAntennaLocation
    @relativeAntennaLocation.setter
    def relativeAntennaLocation(self, value = [0, 0, 0]):
        self.__relativeAntennaLocation = [value]
    def setRelativeAntennaLocation(self, relativeAntennaLocation = [0, 0, 0]):
        self.__relativeAntennaLocation = [relativeAntennaLocation]
        return self
    def addRelativeAntennaLocation(self, relativeAntennaLocation = [0, 0, 0]):
        if self.__relativeAntennaLocation == None:            self.__relativeAntennaLocation =  []
        self.__relativeAntennaLocation +=  [relativeAntennaLocation]
        return self
    def removeRelativeAntennaLocation(self, relativeAntennaLocation):
        self.__relativeAntennaLocation = [x for x in self.__relativeAntennaLocation if x not in relativeAntennaLocation]
        return self.__relativeAntennaLocation
    def getRelativeAntennaLocation(self, relativeAntennaLocation = [0, 0, 0]):
        return self.__relativeAntennaLocation
    def relativeAntennaLocation_changed(self, relativeAntennaLocation = [0, 0, 0]):
        return self.__relativeAntennaLocation
    @property
    def siteID(self):
        return self.__siteID
    @siteID.setter
    def siteID(self, value = 0):
        self.__siteID = [value]
    def setSiteID(self, siteID = 0):
        self.__siteID = [siteID]
        return self
    def addSiteID(self, siteID = 0):
        if self.__siteID == None:            self.__siteID =  []
        self.__siteID +=  [siteID]
        return self
    def removeSiteID(self, siteID):
        self.__siteID = [x for x in self.__siteID if x not in siteID]
        return self.__siteID
    def getSiteID(self, siteID = 0):
        return self.__siteID
    def siteID_changed(self, siteID = 0):
        return self.__siteID
    def removeTimestamp(self, timestamp):
        self.__timestamp = [x for x in self.__timestamp if x not in timestamp]
        return self.__timestamp
    def getTimestamp(self, timestamp = None):
        return self.__timestamp
    def timestamp_changed(self, timestamp = None):
        return self.__timestamp
    @property
    def transmitFrequencyBandwidth(self):
        return self.__transmitFrequencyBandwidth
    @transmitFrequencyBandwidth.setter
    def transmitFrequencyBandwidth(self, value = 0):
        self.__transmitFrequencyBandwidth = [value]
    def setTransmitFrequencyBandwidth(self, transmitFrequencyBandwidth = 0):
        self.__transmitFrequencyBandwidth = [transmitFrequencyBandwidth]
        return self
    def addTransmitFrequencyBandwidth(self, transmitFrequencyBandwidth = 0):
        if self.__transmitFrequencyBandwidth == None:            self.__transmitFrequencyBandwidth =  []
        self.__transmitFrequencyBandwidth +=  [transmitFrequencyBandwidth]
        return self
    def removeTransmitFrequencyBandwidth(self, transmitFrequencyBandwidth):
        self.__transmitFrequencyBandwidth = [x for x in self.__transmitFrequencyBandwidth if x not in transmitFrequencyBandwidth]
        return self.__transmitFrequencyBandwidth
    def getTransmitFrequencyBandwidth(self, transmitFrequencyBandwidth = 0):
        return self.__transmitFrequencyBandwidth
    def transmitFrequencyBandwidth_changed(self, transmitFrequencyBandwidth = 0):
        return self.__transmitFrequencyBandwidth
    @property
    def transmitState(self):
        return self.__transmitState
    @transmitState.setter
    def transmitState(self, value = 0):
        self.__transmitState = [value]
    def setTransmitState(self, transmitState = 0):
        self.__transmitState = [transmitState]
        return self
    def addTransmitState(self, transmitState = 0):
        if self.__transmitState == None:            self.__transmitState =  []
        self.__transmitState +=  [transmitState]
        return self
    def removeTransmitState(self, transmitState):
        self.__transmitState = [x for x in self.__transmitState if x not in transmitState]
        return self.__transmitState
    def getTransmitState(self, transmitState = 0):
        return self.__transmitState
    def transmitState_changed(self, transmitState = 0):
        return self.__transmitState
    @property
    def whichGeometry(self):
        return self.__whichGeometry
    @whichGeometry.setter
    def whichGeometry(self, value = 1):
        self.__whichGeometry = [value]
    def setWhichGeometry(self, whichGeometry = 1):
        self.__whichGeometry = [whichGeometry]
        return self
    def addWhichGeometry(self, whichGeometry = 1):
        if self.__whichGeometry == None:            self.__whichGeometry =  []
        self.__whichGeometry +=  [whichGeometry]
        return self
    def removeWhichGeometry(self, whichGeometry):
        self.__whichGeometry = [x for x in self.__whichGeometry if x not in whichGeometry]
        return self.__whichGeometry
    def getWhichGeometry(self, whichGeometry = 1):
        return self.__whichGeometry
    def whichGeometry_changed(self, whichGeometry = 1):
        return self.__whichGeometry
    @property
    def writeInterval(self):
        return self.__writeInterval
    @writeInterval.setter
    def writeInterval(self, value = 1.0):
        if value == None or value  <  0:
            return None
        self.__writeInterval = [value]
    def setWriteInterval(self, writeInterval = 1.0):
        if writeInterval == None or writeInterval  <  0:
            return None
        self.__writeInterval = [writeInterval]
        return self
    def addWriteInterval(self, writeInterval = 1.0):
        if writeInterval == None or writeInterval  <  0:
            return None
        if self.__writeInterval == None:            self.__writeInterval =  []
        self.__writeInterval +=  [writeInterval]
        return self
    def removeWriteInterval(self, writeInterval):
        self.__writeInterval = [x for x in self.__writeInterval if x not in writeInterval]
        return self.__writeInterval
    def getWriteInterval(self, writeInterval = 1.0):
        return self.__writeInterval
    def writeInterval_changed(self, writeInterval = 1.0):
        return self.__writeInterval
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<TransmitterPdu'
        if self.__address is not None:
            if isinstance(self.__address, six.string_types):
                str += ' address="'+self.__address+'"'
            else:
                str += ' address="'+self.__address[0]+'"'
        if self.__antennaLocation is not None:
            if isinstance(self.__antennaLocation, six.string_types):
                str += ' antennaLocation="'+self.__antennaLocation+'"'
            else:
                str += ' antennaLocation="'+self.__antennaLocation[0]+'"'
        if self.__antennaPatternLength is not None:
            if isinstance(self.__antennaPatternLength, six.string_types):
                str += ' antennaPatternLength="'+self.__antennaPatternLength+'"'
            else:
                str += ' antennaPatternLength="'+self.__antennaPatternLength[0]+'"'
        if self.__antennaPatternType is not None:
            if isinstance(self.__antennaPatternType, six.string_types):
                str += ' antennaPatternType="'+self.__antennaPatternType+'"'
            else:
                str += ' antennaPatternType="'+self.__antennaPatternType[0]+'"'
        if self.__applicationID is not None:
            if isinstance(self.__applicationID, six.string_types):
                str += ' applicationID="'+self.__applicationID+'"'
            else:
                str += ' applicationID="'+self.__applicationID[0]+'"'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__cryptoKeyID is not None:
            if isinstance(self.__cryptoKeyID, six.string_types):
                str += ' cryptoKeyID="'+self.__cryptoKeyID+'"'
            else:
                str += ' cryptoKeyID="'+self.__cryptoKeyID[0]+'"'
        if self.__cryptoSystem is not None:
            if isinstance(self.__cryptoSystem, six.string_types):
                str += ' cryptoSystem="'+self.__cryptoSystem+'"'
            else:
                str += ' cryptoSystem="'+self.__cryptoSystem[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__entityID is not None:
            if isinstance(self.__entityID, six.string_types):
                str += ' entityID="'+self.__entityID+'"'
            else:
                str += ' entityID="'+self.__entityID[0]+'"'
        if self.__frequency is not None:
            if isinstance(self.__frequency, six.string_types):
                str += ' frequency="'+self.__frequency+'"'
            else:
                str += ' frequency="'+self.__frequency[0]+'"'
        if self.__geoCoords is not None:
            if isinstance(self.__geoCoords, six.string_types):
                str += ' geoCoords="'+self.__geoCoords+'"'
            else:
                str += ' geoCoords="'+self.__geoCoords[0]+'"'
        if self.__geoSystem is not None:
            if isinstance(self.__geoSystem, six.string_types):
                str += ' geoSystem="'+self.__geoSystem+'"'
            else:
                str += ' geoSystem="'+self.__geoSystem[0]+'"'
        if self.__inputSource is not None:
            if isinstance(self.__inputSource, six.string_types):
                str += ' inputSource="'+self.__inputSource+'"'
            else:
                str += ' inputSource="'+self.__inputSource[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__NetworkReader is not None:
            if isinstance(self.__NetworkReader, six.string_types):
                str += ' NetworkReader="'+self.__NetworkReader+'"'
            else:
                str += ' NetworkReader="'+self.__NetworkReader[0]+'"'
        if self.__NetworkWriter is not None:
            if isinstance(self.__NetworkWriter, six.string_types):
                str += ' NetworkWriter="'+self.__NetworkWriter+'"'
            else:
                str += ' NetworkWriter="'+self.__NetworkWriter[0]+'"'
        if self.__RtpHeaderHeard is not None:
            if isinstance(self.__RtpHeaderHeard, six.string_types):
                str += ' RtpHeaderHeard="'+self.__RtpHeaderHeard+'"'
            else:
                str += ' RtpHeaderHeard="'+self.__RtpHeaderHeard[0]+'"'
        if self.__StandAlone is not None:
            if isinstance(self.__StandAlone, six.string_types):
                str += ' StandAlone="'+self.__StandAlone+'"'
            else:
                str += ' StandAlone="'+self.__StandAlone[0]+'"'
        if self.__lengthOfModulationParameters is not None:
            if isinstance(self.__lengthOfModulationParameters, six.string_types):
                str += ' lengthOfModulationParameters="'+self.__lengthOfModulationParameters+'"'
            else:
                str += ' lengthOfModulationParameters="'+self.__lengthOfModulationParameters[0]+'"'
        if self.__modulationTypeDetail is not None:
            if isinstance(self.__modulationTypeDetail, six.string_types):
                str += ' modulationTypeDetail="'+self.__modulationTypeDetail+'"'
            else:
                str += ' modulationTypeDetail="'+self.__modulationTypeDetail[0]+'"'
        if self.__modulationTypeMajor is not None:
            if isinstance(self.__modulationTypeMajor, six.string_types):
                str += ' modulationTypeMajor="'+self.__modulationTypeMajor+'"'
            else:
                str += ' modulationTypeMajor="'+self.__modulationTypeMajor[0]+'"'
        if self.__modulationTypeSpreadSpectrum is not None:
            if isinstance(self.__modulationTypeSpreadSpectrum, six.string_types):
                str += ' modulationTypeSpreadSpectrum="'+self.__modulationTypeSpreadSpectrum+'"'
            else:
                str += ' modulationTypeSpreadSpectrum="'+self.__modulationTypeSpreadSpectrum[0]+'"'
        if self.__modulationTypeSystem is not None:
            if isinstance(self.__modulationTypeSystem, six.string_types):
                str += ' modulationTypeSystem="'+self.__modulationTypeSystem+'"'
            else:
                str += ' modulationTypeSystem="'+self.__modulationTypeSystem[0]+'"'
        if self.__multicastRelayHost is not None:
            if isinstance(self.__multicastRelayHost, six.string_types):
                str += ' multicastRelayHost="'+self.__multicastRelayHost+'"'
            else:
                str += ' multicastRelayHost="'+self.__multicastRelayHost[0]+'"'
        if self.__multicastRelayPort is not None:
            if isinstance(self.__multicastRelayPort, six.string_types):
                str += ' multicastRelayPort="'+self.__multicastRelayPort+'"'
            else:
                str += ' multicastRelayPort="'+self.__multicastRelayPort[0]+'"'
        if self.__networkMode is not None:
            if isinstance(self.__networkMode, six.string_types):
                str += ' networkMode="'+self.__networkMode+'"'
            else:
                str += ' networkMode="'+self.__networkMode[0]+'"'
        if self.__port is not None:
            if isinstance(self.__port, six.string_types):
                str += ' port="'+self.__port+'"'
            else:
                str += ' port="'+self.__port[0]+'"'
        if self.__power is not None:
            if isinstance(self.__power, six.string_types):
                str += ' power="'+self.__power+'"'
            else:
                str += ' power="'+self.__power[0]+'"'
        if self.__radioEntityTypeCategory is not None:
            if isinstance(self.__radioEntityTypeCategory, six.string_types):
                str += ' radioEntityTypeCategory="'+self.__radioEntityTypeCategory+'"'
            else:
                str += ' radioEntityTypeCategory="'+self.__radioEntityTypeCategory[0]+'"'
        if self.__radioEntityTypeCountry is not None:
            if isinstance(self.__radioEntityTypeCountry, six.string_types):
                str += ' radioEntityTypeCountry="'+self.__radioEntityTypeCountry+'"'
            else:
                str += ' radioEntityTypeCountry="'+self.__radioEntityTypeCountry[0]+'"'
        if self.__radioEntityTypeDomain is not None:
            if isinstance(self.__radioEntityTypeDomain, six.string_types):
                str += ' radioEntityTypeDomain="'+self.__radioEntityTypeDomain+'"'
            else:
                str += ' radioEntityTypeDomain="'+self.__radioEntityTypeDomain[0]+'"'
        if self.__radioEntityTypeKind is not None:
            if isinstance(self.__radioEntityTypeKind, six.string_types):
                str += ' radioEntityTypeKind="'+self.__radioEntityTypeKind+'"'
            else:
                str += ' radioEntityTypeKind="'+self.__radioEntityTypeKind[0]+'"'
        if self.__radioEntityTypeNomenclature is not None:
            if isinstance(self.__radioEntityTypeNomenclature, six.string_types):
                str += ' radioEntityTypeNomenclature="'+self.__radioEntityTypeNomenclature+'"'
            else:
                str += ' radioEntityTypeNomenclature="'+self.__radioEntityTypeNomenclature[0]+'"'
        if self.__radioEntityTypeNomenclatureVersion is not None:
            if isinstance(self.__radioEntityTypeNomenclatureVersion, six.string_types):
                str += ' radioEntityTypeNomenclatureVersion="'+self.__radioEntityTypeNomenclatureVersion+'"'
            else:
                str += ' radioEntityTypeNomenclatureVersion="'+self.__radioEntityTypeNomenclatureVersion[0]+'"'
        if self.__radioID is not None:
            if isinstance(self.__radioID, six.string_types):
                str += ' radioID="'+self.__radioID+'"'
            else:
                str += ' radioID="'+self.__radioID[0]+'"'
        if self.__readInterval is not None:
            if isinstance(self.__readInterval, six.string_types):
                str += ' readInterval="'+self.__readInterval+'"'
            else:
                str += ' readInterval="'+self.__readInterval[0]+'"'
        if self.__relativeAntennaLocation is not None:
            if isinstance(self.__relativeAntennaLocation, six.string_types):
                str += ' relativeAntennaLocation="'+self.__relativeAntennaLocation+'"'
            else:
                str += ' relativeAntennaLocation="'+self.__relativeAntennaLocation[0]+'"'
        if self.__rtpHeaderExpected is not None:
            if isinstance(self.__rtpHeaderExpected, six.string_types):
                str += ' rtpHeaderExpected="'+self.__rtpHeaderExpected+'"'
            else:
                str += ' rtpHeaderExpected="'+self.__rtpHeaderExpected[0]+'"'
        if self.__siteID is not None:
            if isinstance(self.__siteID, six.string_types):
                str += ' siteID="'+self.__siteID+'"'
            else:
                str += ' siteID="'+self.__siteID[0]+'"'
        if self.__timestamp is not None:
            if isinstance(self.__timestamp, six.string_types):
                str += ' timestamp="'+self.__timestamp+'"'
            else:
                str += ' timestamp="'+self.__timestamp[0]+'"'
        if self.__transmitFrequencyBandwidth is not None:
            if isinstance(self.__transmitFrequencyBandwidth, six.string_types):
                str += ' transmitFrequencyBandwidth="'+self.__transmitFrequencyBandwidth+'"'
            else:
                str += ' transmitFrequencyBandwidth="'+self.__transmitFrequencyBandwidth[0]+'"'
        if self.__transmitState is not None:
            if isinstance(self.__transmitState, six.string_types):
                str += ' transmitState="'+self.__transmitState+'"'
            else:
                str += ' transmitState="'+self.__transmitState[0]+'"'
        if self.__whichGeometry is not None:
            if isinstance(self.__whichGeometry, six.string_types):
                str += ' whichGeometry="'+self.__whichGeometry+'"'
            else:
                str += ' whichGeometry="'+self.__whichGeometry[0]+'"'
        if self.__writeInterval is not None:
            if isinstance(self.__writeInterval, six.string_types):
                str += ' writeInterval="'+self.__writeInterval+'"'
            else:
                str += ' writeInterval="'+self.__writeInterval[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</TransmitterPdu>'
        return str


class TriangleFanSet(X3DComposedGeometryNode):
    def __init__(self, **kwargs):
        super(TriangleFanSet, self).__init__(**kwargs)
        attrib  = kwargs.pop("attrib", None)
        self.__attrib = attrib
        ccw  = kwargs.pop("ccw", True)
        self.__ccw = ccw
        color  = kwargs.pop("color", None)
        self.__color = color
        colorPerVertex  = kwargs.pop("colorPerVertex", True)
        self.__colorPerVertex = colorPerVertex
        coord  = kwargs.pop("coord", None)
        self.__coord = coord
        fanCount  = kwargs.pop("fanCount", None)
        if fanCount == None or len(fanCount) <= 0 or min(fanCount)  <  3:
            return None
        self.__fanCount = fanCount
        fogCoord  = kwargs.pop("fogCoord", None)
        self.__fogCoord = fogCoord
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        normal  = kwargs.pop("normal", None)
        self.__normal = normal
        normalPerVertex  = kwargs.pop("normalPerVertex", True)
        self.__normalPerVertex = normalPerVertex
        solid  = kwargs.pop("solid", True)
        self.__solid = solid
        texCoord  = kwargs.pop("texCoord", None)
        self.__texCoord = texCoord
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def attrib(self):
        return self.__attrib
    @attrib.setter
    def attrib(self, value = None):
        self.__attrib = [value]
    def setAttrib(self, attrib = None):
        self.__attrib = [attrib]
        return self
    def addAttrib(self, attrib = None):
        if self.__attrib == None:            self.__attrib =  []
        self.__attrib +=  [attrib]
        return self
    def removeAttrib(self, attrib):
        self.__attrib = [x for x in self.__attrib if x not in attrib]
        return self.__attrib
    def getAttrib(self, attrib = None):
        return self.__attrib
    def attrib_changed(self, attrib = None):
        return self.__attrib
    @property
    def color(self):
        return self.__color
    @color.setter
    def color(self, value = None):
        self.__color = [value]
    def setColor(self, color = None):
        self.__color = [color]
        return self
    def addColor(self, color = None):
        if self.__color == None:            self.__color =  []
        self.__color +=  [color]
        return self
    def removeColor(self, color):
        self.__color = [x for x in self.__color if x not in color]
        return self.__color
    def getColor(self, color = None):
        return self.__color
    def color_changed(self, color = None):
        return self.__color
    @property
    def coord(self):
        return self.__coord
    @coord.setter
    def coord(self, value = None):
        self.__coord = [value]
    def setCoord(self, coord = None):
        self.__coord = [coord]
        return self
    def addCoord(self, coord = None):
        if self.__coord == None:            self.__coord =  []
        self.__coord +=  [coord]
        return self
    def removeCoord(self, coord):
        self.__coord = [x for x in self.__coord if x not in coord]
        return self.__coord
    def getCoord(self, coord = None):
        return self.__coord
    def coord_changed(self, coord = None):
        return self.__coord
    @property
    def fanCount(self):
        return self.__fanCount
    @fanCount.setter
    def fanCount(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  3:
            return None
        self.__fanCount = [value]
    def setFanCount(self, fanCount = None):
        if fanCount == None or len(fanCount) <= 0 or min(fanCount)  <  3:
            return None
        self.__fanCount = [fanCount]
        return self
    def addFanCount(self, fanCount = None):
        if fanCount == None or len(fanCount) <= 0 or min(fanCount)  <  3:
            return None
        if self.__fanCount == None:            self.__fanCount =  []
        self.__fanCount +=  [fanCount]
        return self
    def removeFanCount(self, fanCount):
        self.__fanCount = [x for x in self.__fanCount if x not in fanCount]
        return self.__fanCount
    def getFanCount(self, fanCount = None):
        return self.__fanCount
    def fanCount_changed(self, fanCount = None):
        return self.__fanCount
    @property
    def fogCoord(self):
        return self.__fogCoord
    @fogCoord.setter
    def fogCoord(self, value = None):
        self.__fogCoord = [value]
    def setFogCoord(self, fogCoord = None):
        self.__fogCoord = [fogCoord]
        return self
    def addFogCoord(self, fogCoord = None):
        if self.__fogCoord == None:            self.__fogCoord =  []
        self.__fogCoord +=  [fogCoord]
        return self
    def removeFogCoord(self, fogCoord):
        self.__fogCoord = [x for x in self.__fogCoord if x not in fogCoord]
        return self.__fogCoord
    def getFogCoord(self, fogCoord = None):
        return self.__fogCoord
    def fogCoord_changed(self, fogCoord = None):
        return self.__fogCoord
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def normal(self):
        return self.__normal
    @normal.setter
    def normal(self, value = None):
        self.__normal = [value]
    def setNormal(self, normal = None):
        self.__normal = [normal]
        return self
    def addNormal(self, normal = None):
        if self.__normal == None:            self.__normal =  []
        self.__normal +=  [normal]
        return self
    def removeNormal(self, normal):
        self.__normal = [x for x in self.__normal if x not in normal]
        return self.__normal
    def getNormal(self, normal = None):
        return self.__normal
    def normal_changed(self, normal = None):
        return self.__normal
    @property
    def texCoord(self):
        return self.__texCoord
    @texCoord.setter
    def texCoord(self, value = None):
        self.__texCoord = [value]
    def setTexCoord(self, texCoord = None):
        self.__texCoord = [texCoord]
        return self
    def addTexCoord(self, texCoord = None):
        if self.__texCoord == None:            self.__texCoord =  []
        self.__texCoord +=  [texCoord]
        return self
    def removeTexCoord(self, texCoord):
        self.__texCoord = [x for x in self.__texCoord if x not in texCoord]
        return self.__texCoord
    def getTexCoord(self, texCoord = None):
        return self.__texCoord
    def texCoord_changed(self, texCoord = None):
        return self.__texCoord
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<TriangleFanSet'
        if self.__ccw is not None:
            if isinstance(self.__ccw, six.string_types):
                str += ' ccw="'+self.__ccw+'"'
            else:
                str += ' ccw="'+self.__ccw[0]+'"'
        if self.__colorPerVertex is not None:
            if isinstance(self.__colorPerVertex, six.string_types):
                str += ' colorPerVertex="'+self.__colorPerVertex+'"'
            else:
                str += ' colorPerVertex="'+self.__colorPerVertex[0]+'"'
        if self.__fanCount is not None:
            if isinstance(self.__fanCount, six.string_types):
                str += ' fanCount="'+self.__fanCount+'"'
            else:
                str += ' fanCount="'+self.__fanCount[0]+'"'
        if self.__normalPerVertex is not None:
            if isinstance(self.__normalPerVertex, six.string_types):
                str += ' normalPerVertex="'+self.__normalPerVertex+'"'
            else:
                str += ' normalPerVertex="'+self.__normalPerVertex[0]+'"'
        if self.__solid is not None:
            if isinstance(self.__solid, six.string_types):
                str += ' solid="'+self.__solid+'"'
            else:
                str += ' solid="'+self.__solid[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<attrib'
        if self.__attrib is not None:
           for s in self.__attrib:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__attrib is not None:
           for s in self.__attrib:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</attrib>'
        str += '<color'
        if self.__color is not None:
           for s in self.__color:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__color is not None:
           for s in self.__color:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</color>'
        str += '<coord'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</coord>'
        str += '<fogCoord'
        if self.__fogCoord is not None:
           for s in self.__fogCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__fogCoord is not None:
           for s in self.__fogCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</fogCoord>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<normal'
        if self.__normal is not None:
           for s in self.__normal:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__normal is not None:
           for s in self.__normal:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</normal>'
        str += '<texCoord'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</texCoord>'
        str += '</TriangleFanSet>'
        return str


class TriangleSet(X3DComposedGeometryNode):
    def __init__(self, **kwargs):
        super(TriangleSet, self).__init__(**kwargs)
        attrib  = kwargs.pop("attrib", None)
        self.__attrib = attrib
        ccw  = kwargs.pop("ccw", True)
        self.__ccw = ccw
        color  = kwargs.pop("color", None)
        self.__color = color
        colorPerVertex  = kwargs.pop("colorPerVertex", True)
        self.__colorPerVertex = colorPerVertex
        coord  = kwargs.pop("coord", None)
        self.__coord = coord
        fogCoord  = kwargs.pop("fogCoord", None)
        self.__fogCoord = fogCoord
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        normal  = kwargs.pop("normal", None)
        self.__normal = normal
        normalPerVertex  = kwargs.pop("normalPerVertex", True)
        self.__normalPerVertex = normalPerVertex
        solid  = kwargs.pop("solid", True)
        self.__solid = solid
        texCoord  = kwargs.pop("texCoord", None)
        self.__texCoord = texCoord
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def attrib(self):
        return self.__attrib
    @attrib.setter
    def attrib(self, value = None):
        self.__attrib = [value]
    def setAttrib(self, attrib = None):
        self.__attrib = [attrib]
        return self
    def addAttrib(self, attrib = None):
        if self.__attrib == None:            self.__attrib =  []
        self.__attrib +=  [attrib]
        return self
    def removeAttrib(self, attrib):
        self.__attrib = [x for x in self.__attrib if x not in attrib]
        return self.__attrib
    def getAttrib(self, attrib = None):
        return self.__attrib
    def attrib_changed(self, attrib = None):
        return self.__attrib
    @property
    def color(self):
        return self.__color
    @color.setter
    def color(self, value = None):
        self.__color = [value]
    def setColor(self, color = None):
        self.__color = [color]
        return self
    def addColor(self, color = None):
        if self.__color == None:            self.__color =  []
        self.__color +=  [color]
        return self
    def removeColor(self, color):
        self.__color = [x for x in self.__color if x not in color]
        return self.__color
    def getColor(self, color = None):
        return self.__color
    def color_changed(self, color = None):
        return self.__color
    @property
    def coord(self):
        return self.__coord
    @coord.setter
    def coord(self, value = None):
        self.__coord = [value]
    def setCoord(self, coord = None):
        self.__coord = [coord]
        return self
    def addCoord(self, coord = None):
        if self.__coord == None:            self.__coord =  []
        self.__coord +=  [coord]
        return self
    def removeCoord(self, coord):
        self.__coord = [x for x in self.__coord if x not in coord]
        return self.__coord
    def getCoord(self, coord = None):
        return self.__coord
    def coord_changed(self, coord = None):
        return self.__coord
    @property
    def fogCoord(self):
        return self.__fogCoord
    @fogCoord.setter
    def fogCoord(self, value = None):
        self.__fogCoord = [value]
    def setFogCoord(self, fogCoord = None):
        self.__fogCoord = [fogCoord]
        return self
    def addFogCoord(self, fogCoord = None):
        if self.__fogCoord == None:            self.__fogCoord =  []
        self.__fogCoord +=  [fogCoord]
        return self
    def removeFogCoord(self, fogCoord):
        self.__fogCoord = [x for x in self.__fogCoord if x not in fogCoord]
        return self.__fogCoord
    def getFogCoord(self, fogCoord = None):
        return self.__fogCoord
    def fogCoord_changed(self, fogCoord = None):
        return self.__fogCoord
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def normal(self):
        return self.__normal
    @normal.setter
    def normal(self, value = None):
        self.__normal = [value]
    def setNormal(self, normal = None):
        self.__normal = [normal]
        return self
    def addNormal(self, normal = None):
        if self.__normal == None:            self.__normal =  []
        self.__normal +=  [normal]
        return self
    def removeNormal(self, normal):
        self.__normal = [x for x in self.__normal if x not in normal]
        return self.__normal
    def getNormal(self, normal = None):
        return self.__normal
    def normal_changed(self, normal = None):
        return self.__normal
    @property
    def texCoord(self):
        return self.__texCoord
    @texCoord.setter
    def texCoord(self, value = None):
        self.__texCoord = [value]
    def setTexCoord(self, texCoord = None):
        self.__texCoord = [texCoord]
        return self
    def addTexCoord(self, texCoord = None):
        if self.__texCoord == None:            self.__texCoord =  []
        self.__texCoord +=  [texCoord]
        return self
    def removeTexCoord(self, texCoord):
        self.__texCoord = [x for x in self.__texCoord if x not in texCoord]
        return self.__texCoord
    def getTexCoord(self, texCoord = None):
        return self.__texCoord
    def texCoord_changed(self, texCoord = None):
        return self.__texCoord
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<TriangleSet'
        if self.__ccw is not None:
            if isinstance(self.__ccw, six.string_types):
                str += ' ccw="'+self.__ccw+'"'
            else:
                str += ' ccw="'+self.__ccw[0]+'"'
        if self.__colorPerVertex is not None:
            if isinstance(self.__colorPerVertex, six.string_types):
                str += ' colorPerVertex="'+self.__colorPerVertex+'"'
            else:
                str += ' colorPerVertex="'+self.__colorPerVertex[0]+'"'
        if self.__normalPerVertex is not None:
            if isinstance(self.__normalPerVertex, six.string_types):
                str += ' normalPerVertex="'+self.__normalPerVertex+'"'
            else:
                str += ' normalPerVertex="'+self.__normalPerVertex[0]+'"'
        if self.__solid is not None:
            if isinstance(self.__solid, six.string_types):
                str += ' solid="'+self.__solid+'"'
            else:
                str += ' solid="'+self.__solid[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<attrib'
        if self.__attrib is not None:
           for s in self.__attrib:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__attrib is not None:
           for s in self.__attrib:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</attrib>'
        str += '<color'
        if self.__color is not None:
           for s in self.__color:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__color is not None:
           for s in self.__color:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</color>'
        str += '<coord'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</coord>'
        str += '<fogCoord'
        if self.__fogCoord is not None:
           for s in self.__fogCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__fogCoord is not None:
           for s in self.__fogCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</fogCoord>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<normal'
        if self.__normal is not None:
           for s in self.__normal:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__normal is not None:
           for s in self.__normal:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</normal>'
        str += '<texCoord'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</texCoord>'
        str += '</TriangleSet>'
        return str


class TriangleSet2D(X3DGeometryNode):
    def __init__(self, **kwargs):
        super(TriangleSet2D, self).__init__(**kwargs)
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        solid  = kwargs.pop("solid", False)
        self.__solid = solid
        vertices  = kwargs.pop("vertices", None)
        self.__vertices = vertices
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def vertices(self):
        return self.__vertices
    @vertices.setter
    def vertices(self, value = None):
        self.__vertices = [value]
    def setVertices(self, vertices = None):
        self.__vertices = [vertices]
        return self
    def addVertices(self, vertices = None):
        if self.__vertices == None:            self.__vertices =  []
        self.__vertices +=  [vertices]
        return self
    def removeVertices(self, vertices):
        self.__vertices = [x for x in self.__vertices if x not in vertices]
        return self.__vertices
    def getVertices(self, vertices = None):
        return self.__vertices
    def vertices_changed(self, vertices = None):
        return self.__vertices
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<TriangleSet2D'
        if self.__solid is not None:
            if isinstance(self.__solid, six.string_types):
                str += ' solid="'+self.__solid+'"'
            else:
                str += ' solid="'+self.__solid[0]+'"'
        if self.__vertices is not None:
            if isinstance(self.__vertices, six.string_types):
                str += ' vertices="'+self.__vertices+'"'
            else:
                str += ' vertices="'+self.__vertices[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</TriangleSet2D>'
        return str


class TriangleStripSet(X3DComposedGeometryNode):
    def __init__(self, **kwargs):
        super(TriangleStripSet, self).__init__(**kwargs)
        attrib  = kwargs.pop("attrib", None)
        self.__attrib = attrib
        ccw  = kwargs.pop("ccw", True)
        self.__ccw = ccw
        color  = kwargs.pop("color", None)
        self.__color = color
        colorPerVertex  = kwargs.pop("colorPerVertex", True)
        self.__colorPerVertex = colorPerVertex
        coord  = kwargs.pop("coord", None)
        self.__coord = coord
        fogCoord  = kwargs.pop("fogCoord", None)
        self.__fogCoord = fogCoord
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        normal  = kwargs.pop("normal", None)
        self.__normal = normal
        normalPerVertex  = kwargs.pop("normalPerVertex", True)
        self.__normalPerVertex = normalPerVertex
        solid  = kwargs.pop("solid", True)
        self.__solid = solid
        stripCount  = kwargs.pop("stripCount", None)
        if stripCount == None or len(stripCount) <= 0 or min(stripCount)  <  3:
            return None
        self.__stripCount = stripCount
        texCoord  = kwargs.pop("texCoord", None)
        self.__texCoord = texCoord
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def attrib(self):
        return self.__attrib
    @attrib.setter
    def attrib(self, value = None):
        self.__attrib = [value]
    def setAttrib(self, attrib = None):
        self.__attrib = [attrib]
        return self
    def addAttrib(self, attrib = None):
        if self.__attrib == None:            self.__attrib =  []
        self.__attrib +=  [attrib]
        return self
    def removeAttrib(self, attrib):
        self.__attrib = [x for x in self.__attrib if x not in attrib]
        return self.__attrib
    def getAttrib(self, attrib = None):
        return self.__attrib
    def attrib_changed(self, attrib = None):
        return self.__attrib
    @property
    def color(self):
        return self.__color
    @color.setter
    def color(self, value = None):
        self.__color = [value]
    def setColor(self, color = None):
        self.__color = [color]
        return self
    def addColor(self, color = None):
        if self.__color == None:            self.__color =  []
        self.__color +=  [color]
        return self
    def removeColor(self, color):
        self.__color = [x for x in self.__color if x not in color]
        return self.__color
    def getColor(self, color = None):
        return self.__color
    def color_changed(self, color = None):
        return self.__color
    @property
    def coord(self):
        return self.__coord
    @coord.setter
    def coord(self, value = None):
        self.__coord = [value]
    def setCoord(self, coord = None):
        self.__coord = [coord]
        return self
    def addCoord(self, coord = None):
        if self.__coord == None:            self.__coord =  []
        self.__coord +=  [coord]
        return self
    def removeCoord(self, coord):
        self.__coord = [x for x in self.__coord if x not in coord]
        return self.__coord
    def getCoord(self, coord = None):
        return self.__coord
    def coord_changed(self, coord = None):
        return self.__coord
    @property
    def fogCoord(self):
        return self.__fogCoord
    @fogCoord.setter
    def fogCoord(self, value = None):
        self.__fogCoord = [value]
    def setFogCoord(self, fogCoord = None):
        self.__fogCoord = [fogCoord]
        return self
    def addFogCoord(self, fogCoord = None):
        if self.__fogCoord == None:            self.__fogCoord =  []
        self.__fogCoord +=  [fogCoord]
        return self
    def removeFogCoord(self, fogCoord):
        self.__fogCoord = [x for x in self.__fogCoord if x not in fogCoord]
        return self.__fogCoord
    def getFogCoord(self, fogCoord = None):
        return self.__fogCoord
    def fogCoord_changed(self, fogCoord = None):
        return self.__fogCoord
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def normal(self):
        return self.__normal
    @normal.setter
    def normal(self, value = None):
        self.__normal = [value]
    def setNormal(self, normal = None):
        self.__normal = [normal]
        return self
    def addNormal(self, normal = None):
        if self.__normal == None:            self.__normal =  []
        self.__normal +=  [normal]
        return self
    def removeNormal(self, normal):
        self.__normal = [x for x in self.__normal if x not in normal]
        return self.__normal
    def getNormal(self, normal = None):
        return self.__normal
    def normal_changed(self, normal = None):
        return self.__normal
    @property
    def stripCount(self):
        return self.__stripCount
    @stripCount.setter
    def stripCount(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  3:
            return None
        self.__stripCount = [value]
    def setStripCount(self, stripCount = None):
        if stripCount == None or len(stripCount) <= 0 or min(stripCount)  <  3:
            return None
        self.__stripCount = [stripCount]
        return self
    def addStripCount(self, stripCount = None):
        if stripCount == None or len(stripCount) <= 0 or min(stripCount)  <  3:
            return None
        if self.__stripCount == None:            self.__stripCount =  []
        self.__stripCount +=  [stripCount]
        return self
    def removeStripCount(self, stripCount):
        self.__stripCount = [x for x in self.__stripCount if x not in stripCount]
        return self.__stripCount
    def getStripCount(self, stripCount = None):
        return self.__stripCount
    def stripCount_changed(self, stripCount = None):
        return self.__stripCount
    @property
    def texCoord(self):
        return self.__texCoord
    @texCoord.setter
    def texCoord(self, value = None):
        self.__texCoord = [value]
    def setTexCoord(self, texCoord = None):
        self.__texCoord = [texCoord]
        return self
    def addTexCoord(self, texCoord = None):
        if self.__texCoord == None:            self.__texCoord =  []
        self.__texCoord +=  [texCoord]
        return self
    def removeTexCoord(self, texCoord):
        self.__texCoord = [x for x in self.__texCoord if x not in texCoord]
        return self.__texCoord
    def getTexCoord(self, texCoord = None):
        return self.__texCoord
    def texCoord_changed(self, texCoord = None):
        return self.__texCoord
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<TriangleStripSet'
        if self.__ccw is not None:
            if isinstance(self.__ccw, six.string_types):
                str += ' ccw="'+self.__ccw+'"'
            else:
                str += ' ccw="'+self.__ccw[0]+'"'
        if self.__colorPerVertex is not None:
            if isinstance(self.__colorPerVertex, six.string_types):
                str += ' colorPerVertex="'+self.__colorPerVertex+'"'
            else:
                str += ' colorPerVertex="'+self.__colorPerVertex[0]+'"'
        if self.__normalPerVertex is not None:
            if isinstance(self.__normalPerVertex, six.string_types):
                str += ' normalPerVertex="'+self.__normalPerVertex+'"'
            else:
                str += ' normalPerVertex="'+self.__normalPerVertex[0]+'"'
        if self.__solid is not None:
            if isinstance(self.__solid, six.string_types):
                str += ' solid="'+self.__solid+'"'
            else:
                str += ' solid="'+self.__solid[0]+'"'
        if self.__stripCount is not None:
            if isinstance(self.__stripCount, six.string_types):
                str += ' stripCount="'+self.__stripCount+'"'
            else:
                str += ' stripCount="'+self.__stripCount[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<attrib'
        if self.__attrib is not None:
           for s in self.__attrib:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__attrib is not None:
           for s in self.__attrib:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</attrib>'
        str += '<color'
        if self.__color is not None:
           for s in self.__color:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__color is not None:
           for s in self.__color:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</color>'
        str += '<coord'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</coord>'
        str += '<fogCoord'
        if self.__fogCoord is not None:
           for s in self.__fogCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__fogCoord is not None:
           for s in self.__fogCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</fogCoord>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<normal'
        if self.__normal is not None:
           for s in self.__normal:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__normal is not None:
           for s in self.__normal:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</normal>'
        str += '<texCoord'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__texCoord is not None:
           for s in self.__texCoord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</texCoord>'
        str += '</TriangleStripSet>'
        return str


class TwoSidedMaterial(X3DMaterialNode):
    def __init__(self, **kwargs):
        super(TwoSidedMaterial, self).__init__(**kwargs)
        ambientIntensity  = kwargs.pop("ambientIntensity", 0.2)
        if ambientIntensity == None or ambientIntensity  <  0:
            return None
        if ambientIntensity == None or ambientIntensity  >  1:
            return None
        self.__ambientIntensity = ambientIntensity
        backAmbientIntensity  = kwargs.pop("backAmbientIntensity", 0.2)
        if backAmbientIntensity == None or backAmbientIntensity  <  0:
            return None
        if backAmbientIntensity == None or backAmbientIntensity  >  1:
            return None
        self.__backAmbientIntensity = backAmbientIntensity
        backDiffuseColor  = kwargs.pop("backDiffuseColor", [0.8, 0.8, 0.8])
        if backDiffuseColor == None or len(backDiffuseColor) <= 0 or min(backDiffuseColor)  <  0:
            return None
        if backDiffuseColor == None or len(backDiffuseColor) <= 0 or max(backDiffuseColor)  >  1:
            return None
        self.__backDiffuseColor = backDiffuseColor
        backEmissiveColor  = kwargs.pop("backEmissiveColor", [0, 0, 0])
        if backEmissiveColor == None or len(backEmissiveColor) <= 0 or min(backEmissiveColor)  <  0:
            return None
        if backEmissiveColor == None or len(backEmissiveColor) <= 0 or max(backEmissiveColor)  >  1:
            return None
        self.__backEmissiveColor = backEmissiveColor
        backShininess  = kwargs.pop("backShininess", 0.2)
        if backShininess == None or backShininess  <  0:
            return None
        if backShininess == None or backShininess  >  1:
            return None
        self.__backShininess = backShininess
        backSpecularColor  = kwargs.pop("backSpecularColor", [0, 0, 0])
        if backSpecularColor == None or len(backSpecularColor) <= 0 or min(backSpecularColor)  <  0:
            return None
        if backSpecularColor == None or len(backSpecularColor) <= 0 or max(backSpecularColor)  >  1:
            return None
        self.__backSpecularColor = backSpecularColor
        backTransparency  = kwargs.pop("backTransparency", 0)
        if backTransparency == None or backTransparency  <  0:
            return None
        if backTransparency == None or backTransparency  >  1:
            return None
        self.__backTransparency = backTransparency
        diffuseColor  = kwargs.pop("diffuseColor", [0.8, 0.8, 0.8])
        if diffuseColor == None or len(diffuseColor) <= 0 or min(diffuseColor)  <  0:
            return None
        if diffuseColor == None or len(diffuseColor) <= 0 or max(diffuseColor)  >  1:
            return None
        self.__diffuseColor = diffuseColor
        emissiveColor  = kwargs.pop("emissiveColor", [0, 0, 0])
        if emissiveColor == None or len(emissiveColor) <= 0 or min(emissiveColor)  <  0:
            return None
        if emissiveColor == None or len(emissiveColor) <= 0 or max(emissiveColor)  >  1:
            return None
        self.__emissiveColor = emissiveColor
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        separateBackColor  = kwargs.pop("separateBackColor", False)
        self.__separateBackColor = separateBackColor
        shininess  = kwargs.pop("shininess", 0.2)
        if shininess == None or shininess  <  0:
            return None
        if shininess == None or shininess  >  1:
            return None
        self.__shininess = shininess
        specularColor  = kwargs.pop("specularColor", [0, 0, 0])
        if specularColor == None or len(specularColor) <= 0 or min(specularColor)  <  0:
            return None
        if specularColor == None or len(specularColor) <= 0 or max(specularColor)  >  1:
            return None
        self.__specularColor = specularColor
        transparency  = kwargs.pop("transparency", 0)
        if transparency == None or transparency  <  0:
            return None
        if transparency == None or transparency  >  1:
            return None
        self.__transparency = transparency
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def ambientIntensity(self):
        return self.__ambientIntensity
    @ambientIntensity.setter
    def ambientIntensity(self, value = 0.2):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__ambientIntensity = [value]
    def setAmbientIntensity(self, ambientIntensity = 0.2):
        if ambientIntensity == None or ambientIntensity  <  0:
            return None
        if ambientIntensity == None or ambientIntensity  >  1:
            return None
        self.__ambientIntensity = [ambientIntensity]
        return self
    def addAmbientIntensity(self, ambientIntensity = 0.2):
        if ambientIntensity == None or ambientIntensity  <  0:
            return None
        if ambientIntensity == None or ambientIntensity  >  1:
            return None
        if self.__ambientIntensity == None:            self.__ambientIntensity =  []
        self.__ambientIntensity +=  [ambientIntensity]
        return self
    def removeAmbientIntensity(self, ambientIntensity):
        self.__ambientIntensity = [x for x in self.__ambientIntensity if x not in ambientIntensity]
        return self.__ambientIntensity
    def getAmbientIntensity(self, ambientIntensity = 0.2):
        return self.__ambientIntensity
    def ambientIntensity_changed(self, ambientIntensity = 0.2):
        return self.__ambientIntensity
    @property
    def backAmbientIntensity(self):
        return self.__backAmbientIntensity
    @backAmbientIntensity.setter
    def backAmbientIntensity(self, value = 0.2):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__backAmbientIntensity = [value]
    def setBackAmbientIntensity(self, backAmbientIntensity = 0.2):
        if backAmbientIntensity == None or backAmbientIntensity  <  0:
            return None
        if backAmbientIntensity == None or backAmbientIntensity  >  1:
            return None
        self.__backAmbientIntensity = [backAmbientIntensity]
        return self
    def addBackAmbientIntensity(self, backAmbientIntensity = 0.2):
        if backAmbientIntensity == None or backAmbientIntensity  <  0:
            return None
        if backAmbientIntensity == None or backAmbientIntensity  >  1:
            return None
        if self.__backAmbientIntensity == None:            self.__backAmbientIntensity =  []
        self.__backAmbientIntensity +=  [backAmbientIntensity]
        return self
    def removeBackAmbientIntensity(self, backAmbientIntensity):
        self.__backAmbientIntensity = [x for x in self.__backAmbientIntensity if x not in backAmbientIntensity]
        return self.__backAmbientIntensity
    def getBackAmbientIntensity(self, backAmbientIntensity = 0.2):
        return self.__backAmbientIntensity
    def backAmbientIntensity_changed(self, backAmbientIntensity = 0.2):
        return self.__backAmbientIntensity
    @property
    def backDiffuseColor(self):
        return self.__backDiffuseColor
    @backDiffuseColor.setter
    def backDiffuseColor(self, value = [0.8, 0.8, 0.8]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__backDiffuseColor = [value]
    def setBackDiffuseColor(self, backDiffuseColor = [0.8, 0.8, 0.8]):
        if backDiffuseColor == None or len(backDiffuseColor) <= 0 or min(backDiffuseColor)  <  0:
            return None
        if backDiffuseColor == None or len(backDiffuseColor) <= 0 or max(backDiffuseColor)  >  1:
            return None
        self.__backDiffuseColor = [backDiffuseColor]
        return self
    def addBackDiffuseColor(self, backDiffuseColor = [0.8, 0.8, 0.8]):
        if backDiffuseColor == None or len(backDiffuseColor) <= 0 or min(backDiffuseColor)  <  0:
            return None
        if backDiffuseColor == None or len(backDiffuseColor) <= 0 or max(backDiffuseColor)  >  1:
            return None
        if self.__backDiffuseColor == None:            self.__backDiffuseColor =  []
        self.__backDiffuseColor +=  [backDiffuseColor]
        return self
    def removeBackDiffuseColor(self, backDiffuseColor):
        self.__backDiffuseColor = [x for x in self.__backDiffuseColor if x not in backDiffuseColor]
        return self.__backDiffuseColor
    def getBackDiffuseColor(self, backDiffuseColor = [0.8, 0.8, 0.8]):
        return self.__backDiffuseColor
    def backDiffuseColor_changed(self, backDiffuseColor = [0.8, 0.8, 0.8]):
        return self.__backDiffuseColor
    @property
    def backEmissiveColor(self):
        return self.__backEmissiveColor
    @backEmissiveColor.setter
    def backEmissiveColor(self, value = [0, 0, 0]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__backEmissiveColor = [value]
    def setBackEmissiveColor(self, backEmissiveColor = [0, 0, 0]):
        if backEmissiveColor == None or len(backEmissiveColor) <= 0 or min(backEmissiveColor)  <  0:
            return None
        if backEmissiveColor == None or len(backEmissiveColor) <= 0 or max(backEmissiveColor)  >  1:
            return None
        self.__backEmissiveColor = [backEmissiveColor]
        return self
    def addBackEmissiveColor(self, backEmissiveColor = [0, 0, 0]):
        if backEmissiveColor == None or len(backEmissiveColor) <= 0 or min(backEmissiveColor)  <  0:
            return None
        if backEmissiveColor == None or len(backEmissiveColor) <= 0 or max(backEmissiveColor)  >  1:
            return None
        if self.__backEmissiveColor == None:            self.__backEmissiveColor =  []
        self.__backEmissiveColor +=  [backEmissiveColor]
        return self
    def removeBackEmissiveColor(self, backEmissiveColor):
        self.__backEmissiveColor = [x for x in self.__backEmissiveColor if x not in backEmissiveColor]
        return self.__backEmissiveColor
    def getBackEmissiveColor(self, backEmissiveColor = [0, 0, 0]):
        return self.__backEmissiveColor
    def backEmissiveColor_changed(self, backEmissiveColor = [0, 0, 0]):
        return self.__backEmissiveColor
    @property
    def backShininess(self):
        return self.__backShininess
    @backShininess.setter
    def backShininess(self, value = 0.2):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__backShininess = [value]
    def setBackShininess(self, backShininess = 0.2):
        if backShininess == None or backShininess  <  0:
            return None
        if backShininess == None or backShininess  >  1:
            return None
        self.__backShininess = [backShininess]
        return self
    def addBackShininess(self, backShininess = 0.2):
        if backShininess == None or backShininess  <  0:
            return None
        if backShininess == None or backShininess  >  1:
            return None
        if self.__backShininess == None:            self.__backShininess =  []
        self.__backShininess +=  [backShininess]
        return self
    def removeBackShininess(self, backShininess):
        self.__backShininess = [x for x in self.__backShininess if x not in backShininess]
        return self.__backShininess
    def getBackShininess(self, backShininess = 0.2):
        return self.__backShininess
    def backShininess_changed(self, backShininess = 0.2):
        return self.__backShininess
    @property
    def backSpecularColor(self):
        return self.__backSpecularColor
    @backSpecularColor.setter
    def backSpecularColor(self, value = [0, 0, 0]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__backSpecularColor = [value]
    def setBackSpecularColor(self, backSpecularColor = [0, 0, 0]):
        if backSpecularColor == None or len(backSpecularColor) <= 0 or min(backSpecularColor)  <  0:
            return None
        if backSpecularColor == None or len(backSpecularColor) <= 0 or max(backSpecularColor)  >  1:
            return None
        self.__backSpecularColor = [backSpecularColor]
        return self
    def addBackSpecularColor(self, backSpecularColor = [0, 0, 0]):
        if backSpecularColor == None or len(backSpecularColor) <= 0 or min(backSpecularColor)  <  0:
            return None
        if backSpecularColor == None or len(backSpecularColor) <= 0 or max(backSpecularColor)  >  1:
            return None
        if self.__backSpecularColor == None:            self.__backSpecularColor =  []
        self.__backSpecularColor +=  [backSpecularColor]
        return self
    def removeBackSpecularColor(self, backSpecularColor):
        self.__backSpecularColor = [x for x in self.__backSpecularColor if x not in backSpecularColor]
        return self.__backSpecularColor
    def getBackSpecularColor(self, backSpecularColor = [0, 0, 0]):
        return self.__backSpecularColor
    def backSpecularColor_changed(self, backSpecularColor = [0, 0, 0]):
        return self.__backSpecularColor
    @property
    def backTransparency(self):
        return self.__backTransparency
    @backTransparency.setter
    def backTransparency(self, value = 0):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__backTransparency = [value]
    def setBackTransparency(self, backTransparency = 0):
        if backTransparency == None or backTransparency  <  0:
            return None
        if backTransparency == None or backTransparency  >  1:
            return None
        self.__backTransparency = [backTransparency]
        return self
    def addBackTransparency(self, backTransparency = 0):
        if backTransparency == None or backTransparency  <  0:
            return None
        if backTransparency == None or backTransparency  >  1:
            return None
        if self.__backTransparency == None:            self.__backTransparency =  []
        self.__backTransparency +=  [backTransparency]
        return self
    def removeBackTransparency(self, backTransparency):
        self.__backTransparency = [x for x in self.__backTransparency if x not in backTransparency]
        return self.__backTransparency
    def getBackTransparency(self, backTransparency = 0):
        return self.__backTransparency
    def backTransparency_changed(self, backTransparency = 0):
        return self.__backTransparency
    @property
    def diffuseColor(self):
        return self.__diffuseColor
    @diffuseColor.setter
    def diffuseColor(self, value = [0.8, 0.8, 0.8]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__diffuseColor = [value]
    def setDiffuseColor(self, diffuseColor = [0.8, 0.8, 0.8]):
        if diffuseColor == None or len(diffuseColor) <= 0 or min(diffuseColor)  <  0:
            return None
        if diffuseColor == None or len(diffuseColor) <= 0 or max(diffuseColor)  >  1:
            return None
        self.__diffuseColor = [diffuseColor]
        return self
    def addDiffuseColor(self, diffuseColor = [0.8, 0.8, 0.8]):
        if diffuseColor == None or len(diffuseColor) <= 0 or min(diffuseColor)  <  0:
            return None
        if diffuseColor == None or len(diffuseColor) <= 0 or max(diffuseColor)  >  1:
            return None
        if self.__diffuseColor == None:            self.__diffuseColor =  []
        self.__diffuseColor +=  [diffuseColor]
        return self
    def removeDiffuseColor(self, diffuseColor):
        self.__diffuseColor = [x for x in self.__diffuseColor if x not in diffuseColor]
        return self.__diffuseColor
    def getDiffuseColor(self, diffuseColor = [0.8, 0.8, 0.8]):
        return self.__diffuseColor
    def diffuseColor_changed(self, diffuseColor = [0.8, 0.8, 0.8]):
        return self.__diffuseColor
    @property
    def emissiveColor(self):
        return self.__emissiveColor
    @emissiveColor.setter
    def emissiveColor(self, value = [0, 0, 0]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__emissiveColor = [value]
    def setEmissiveColor(self, emissiveColor = [0, 0, 0]):
        if emissiveColor == None or len(emissiveColor) <= 0 or min(emissiveColor)  <  0:
            return None
        if emissiveColor == None or len(emissiveColor) <= 0 or max(emissiveColor)  >  1:
            return None
        self.__emissiveColor = [emissiveColor]
        return self
    def addEmissiveColor(self, emissiveColor = [0, 0, 0]):
        if emissiveColor == None or len(emissiveColor) <= 0 or min(emissiveColor)  <  0:
            return None
        if emissiveColor == None or len(emissiveColor) <= 0 or max(emissiveColor)  >  1:
            return None
        if self.__emissiveColor == None:            self.__emissiveColor =  []
        self.__emissiveColor +=  [emissiveColor]
        return self
    def removeEmissiveColor(self, emissiveColor):
        self.__emissiveColor = [x for x in self.__emissiveColor if x not in emissiveColor]
        return self.__emissiveColor
    def getEmissiveColor(self, emissiveColor = [0, 0, 0]):
        return self.__emissiveColor
    def emissiveColor_changed(self, emissiveColor = [0, 0, 0]):
        return self.__emissiveColor
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def separateBackColor(self):
        return self.__separateBackColor
    @separateBackColor.setter
    def separateBackColor(self, value = False):
        self.__separateBackColor = [value]
    def setSeparateBackColor(self, separateBackColor = False):
        self.__separateBackColor = [separateBackColor]
        return self
    def addSeparateBackColor(self, separateBackColor = False):
        if self.__separateBackColor == None:            self.__separateBackColor =  []
        self.__separateBackColor +=  [separateBackColor]
        return self
    def removeSeparateBackColor(self, separateBackColor):
        self.__separateBackColor = [x for x in self.__separateBackColor if x not in separateBackColor]
        return self.__separateBackColor
    def isSeparateBackColor(self, separateBackColor = False):
        return self.__separateBackColor
    @property
    def shininess(self):
        return self.__shininess
    @shininess.setter
    def shininess(self, value = 0.2):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__shininess = [value]
    def setShininess(self, shininess = 0.2):
        if shininess == None or shininess  <  0:
            return None
        if shininess == None or shininess  >  1:
            return None
        self.__shininess = [shininess]
        return self
    def addShininess(self, shininess = 0.2):
        if shininess == None or shininess  <  0:
            return None
        if shininess == None or shininess  >  1:
            return None
        if self.__shininess == None:            self.__shininess =  []
        self.__shininess +=  [shininess]
        return self
    def removeShininess(self, shininess):
        self.__shininess = [x for x in self.__shininess if x not in shininess]
        return self.__shininess
    def getShininess(self, shininess = 0.2):
        return self.__shininess
    def shininess_changed(self, shininess = 0.2):
        return self.__shininess
    @property
    def specularColor(self):
        return self.__specularColor
    @specularColor.setter
    def specularColor(self, value = [0, 0, 0]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__specularColor = [value]
    def setSpecularColor(self, specularColor = [0, 0, 0]):
        if specularColor == None or len(specularColor) <= 0 or min(specularColor)  <  0:
            return None
        if specularColor == None or len(specularColor) <= 0 or max(specularColor)  >  1:
            return None
        self.__specularColor = [specularColor]
        return self
    def addSpecularColor(self, specularColor = [0, 0, 0]):
        if specularColor == None or len(specularColor) <= 0 or min(specularColor)  <  0:
            return None
        if specularColor == None or len(specularColor) <= 0 or max(specularColor)  >  1:
            return None
        if self.__specularColor == None:            self.__specularColor =  []
        self.__specularColor +=  [specularColor]
        return self
    def removeSpecularColor(self, specularColor):
        self.__specularColor = [x for x in self.__specularColor if x not in specularColor]
        return self.__specularColor
    def getSpecularColor(self, specularColor = [0, 0, 0]):
        return self.__specularColor
    def specularColor_changed(self, specularColor = [0, 0, 0]):
        return self.__specularColor
    @property
    def transparency(self):
        return self.__transparency
    @transparency.setter
    def transparency(self, value = 0):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__transparency = [value]
    def setTransparency(self, transparency = 0):
        if transparency == None or transparency  <  0:
            return None
        if transparency == None or transparency  >  1:
            return None
        self.__transparency = [transparency]
        return self
    def addTransparency(self, transparency = 0):
        if transparency == None or transparency  <  0:
            return None
        if transparency == None or transparency  >  1:
            return None
        if self.__transparency == None:            self.__transparency =  []
        self.__transparency +=  [transparency]
        return self
    def removeTransparency(self, transparency):
        self.__transparency = [x for x in self.__transparency if x not in transparency]
        return self.__transparency
    def getTransparency(self, transparency = 0):
        return self.__transparency
    def transparency_changed(self, transparency = 0):
        return self.__transparency
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<TwoSidedMaterial'
        if self.__ambientIntensity is not None:
            if isinstance(self.__ambientIntensity, six.string_types):
                str += ' ambientIntensity="'+self.__ambientIntensity+'"'
            else:
                str += ' ambientIntensity="'+self.__ambientIntensity[0]+'"'
        if self.__backAmbientIntensity is not None:
            if isinstance(self.__backAmbientIntensity, six.string_types):
                str += ' backAmbientIntensity="'+self.__backAmbientIntensity+'"'
            else:
                str += ' backAmbientIntensity="'+self.__backAmbientIntensity[0]+'"'
        if self.__backDiffuseColor is not None:
            if isinstance(self.__backDiffuseColor, six.string_types):
                str += ' backDiffuseColor="'+self.__backDiffuseColor+'"'
            else:
                str += ' backDiffuseColor="'+self.__backDiffuseColor[0]+'"'
        if self.__backEmissiveColor is not None:
            if isinstance(self.__backEmissiveColor, six.string_types):
                str += ' backEmissiveColor="'+self.__backEmissiveColor+'"'
            else:
                str += ' backEmissiveColor="'+self.__backEmissiveColor[0]+'"'
        if self.__backShininess is not None:
            if isinstance(self.__backShininess, six.string_types):
                str += ' backShininess="'+self.__backShininess+'"'
            else:
                str += ' backShininess="'+self.__backShininess[0]+'"'
        if self.__backSpecularColor is not None:
            if isinstance(self.__backSpecularColor, six.string_types):
                str += ' backSpecularColor="'+self.__backSpecularColor+'"'
            else:
                str += ' backSpecularColor="'+self.__backSpecularColor[0]+'"'
        if self.__backTransparency is not None:
            if isinstance(self.__backTransparency, six.string_types):
                str += ' backTransparency="'+self.__backTransparency+'"'
            else:
                str += ' backTransparency="'+self.__backTransparency[0]+'"'
        if self.__diffuseColor is not None:
            if isinstance(self.__diffuseColor, six.string_types):
                str += ' diffuseColor="'+self.__diffuseColor+'"'
            else:
                str += ' diffuseColor="'+self.__diffuseColor[0]+'"'
        if self.__emissiveColor is not None:
            if isinstance(self.__emissiveColor, six.string_types):
                str += ' emissiveColor="'+self.__emissiveColor+'"'
            else:
                str += ' emissiveColor="'+self.__emissiveColor[0]+'"'
        if self.__separateBackColor is not None:
            if isinstance(self.__separateBackColor, six.string_types):
                str += ' separateBackColor="'+self.__separateBackColor+'"'
            else:
                str += ' separateBackColor="'+self.__separateBackColor[0]+'"'
        if self.__shininess is not None:
            if isinstance(self.__shininess, six.string_types):
                str += ' shininess="'+self.__shininess+'"'
            else:
                str += ' shininess="'+self.__shininess[0]+'"'
        if self.__specularColor is not None:
            if isinstance(self.__specularColor, six.string_types):
                str += ' specularColor="'+self.__specularColor+'"'
            else:
                str += ' specularColor="'+self.__specularColor[0]+'"'
        if self.__transparency is not None:
            if isinstance(self.__transparency, six.string_types):
                str += ' transparency="'+self.__transparency+'"'
            else:
                str += ' transparency="'+self.__transparency[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</TwoSidedMaterial>'
        return str


class UniversalJoint(X3DRigidJointNode):
    def __init__(self, **kwargs):
        super(UniversalJoint, self).__init__(**kwargs)
        anchorPoint  = kwargs.pop("anchorPoint", [0, 0, 0])
        self.__anchorPoint = anchorPoint
        axis1  = kwargs.pop("axis1", [0, 0, 0])
        self.__axis1 = axis1
        axis2  = kwargs.pop("axis2", [0, 0, 0])
        self.__axis2 = axis2
        body1  = kwargs.pop("body1", None)
        self.__body1 = body1
        body1AnchorPoint  = kwargs.pop("body1AnchorPoint", None)
        self.__body1AnchorPoint = body1AnchorPoint
        body1Axis  = kwargs.pop("body1Axis", None)
        self.__body1Axis = body1Axis
        body2  = kwargs.pop("body2", None)
        self.__body2 = body2
        body2AnchorPoint  = kwargs.pop("body2AnchorPoint", None)
        self.__body2AnchorPoint = body2AnchorPoint
        body2Axis  = kwargs.pop("body2Axis", None)
        self.__body2Axis = body2Axis
        forceOutput  = kwargs.pop("forceOutput", ["NONE"])
        self.__forceOutput = forceOutput
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        stop1Bounce  = kwargs.pop("stop1Bounce", 0)
        if stop1Bounce == None or stop1Bounce  <  0:
            return None
        if stop1Bounce == None or stop1Bounce  >  1:
            return None
        self.__stop1Bounce = stop1Bounce
        stop1ErrorCorrection  = kwargs.pop("stop1ErrorCorrection", 0.8)
        if stop1ErrorCorrection == None or stop1ErrorCorrection  <  0:
            return None
        if stop1ErrorCorrection == None or stop1ErrorCorrection  >  1:
            return None
        self.__stop1ErrorCorrection = stop1ErrorCorrection
        stop2Bounce  = kwargs.pop("stop2Bounce", 0)
        if stop2Bounce == None or stop2Bounce  <  0:
            return None
        if stop2Bounce == None or stop2Bounce  >  1:
            return None
        self.__stop2Bounce = stop2Bounce
        stop2ErrorCorrection  = kwargs.pop("stop2ErrorCorrection", 0.8)
        if stop2ErrorCorrection == None or stop2ErrorCorrection  <  0:
            return None
        if stop2ErrorCorrection == None or stop2ErrorCorrection  >  1:
            return None
        self.__stop2ErrorCorrection = stop2ErrorCorrection
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def anchorPoint(self):
        return self.__anchorPoint
    @anchorPoint.setter
    def anchorPoint(self, value = [0, 0, 0]):
        self.__anchorPoint = [value]
    def setAnchorPoint(self, anchorPoint = [0, 0, 0]):
        self.__anchorPoint = [anchorPoint]
        return self
    def addAnchorPoint(self, anchorPoint = [0, 0, 0]):
        if self.__anchorPoint == None:            self.__anchorPoint =  []
        self.__anchorPoint +=  [anchorPoint]
        return self
    def removeAnchorPoint(self, anchorPoint):
        self.__anchorPoint = [x for x in self.__anchorPoint if x not in anchorPoint]
        return self.__anchorPoint
    def getAnchorPoint(self, anchorPoint = [0, 0, 0]):
        return self.__anchorPoint
    def anchorPoint_changed(self, anchorPoint = [0, 0, 0]):
        return self.__anchorPoint
    @property
    def axis1(self):
        return self.__axis1
    @axis1.setter
    def axis1(self, value = [0, 0, 0]):
        self.__axis1 = [value]
    def setAxis1(self, axis1 = [0, 0, 0]):
        self.__axis1 = [axis1]
        return self
    def addAxis1(self, axis1 = [0, 0, 0]):
        if self.__axis1 == None:            self.__axis1 =  []
        self.__axis1 +=  [axis1]
        return self
    def removeAxis1(self, axis1):
        self.__axis1 = [x for x in self.__axis1 if x not in axis1]
        return self.__axis1
    def getAxis1(self, axis1 = [0, 0, 0]):
        return self.__axis1
    def axis1_changed(self, axis1 = [0, 0, 0]):
        return self.__axis1
    @property
    def axis2(self):
        return self.__axis2
    @axis2.setter
    def axis2(self, value = [0, 0, 0]):
        self.__axis2 = [value]
    def setAxis2(self, axis2 = [0, 0, 0]):
        self.__axis2 = [axis2]
        return self
    def addAxis2(self, axis2 = [0, 0, 0]):
        if self.__axis2 == None:            self.__axis2 =  []
        self.__axis2 +=  [axis2]
        return self
    def removeAxis2(self, axis2):
        self.__axis2 = [x for x in self.__axis2 if x not in axis2]
        return self.__axis2
    def getAxis2(self, axis2 = [0, 0, 0]):
        return self.__axis2
    def axis2_changed(self, axis2 = [0, 0, 0]):
        return self.__axis2
    @property
    def body1(self):
        return self.__body1
    @body1.setter
    def body1(self, value = None):
        self.__body1 = [value]
    def setBody1(self, body1 = None):
        self.__body1 = [body1]
        return self
    def addBody1(self, body1 = None):
        if self.__body1 == None:            self.__body1 =  []
        self.__body1 +=  [body1]
        return self
    def removeBody1(self, body1):
        self.__body1 = [x for x in self.__body1 if x not in body1]
        return self.__body1
    def getBody1(self, body1 = None):
        return self.__body1
    def body1_changed(self, body1 = None):
        return self.__body1
    def removeBody1AnchorPoint(self, body1AnchorPoint):
        self.__body1AnchorPoint = [x for x in self.__body1AnchorPoint if x not in body1AnchorPoint]
        return self.__body1AnchorPoint
    def getBody1AnchorPoint(self, body1AnchorPoint = None):
        return self.__body1AnchorPoint
    def body1AnchorPoint_changed(self, body1AnchorPoint = None):
        return self.__body1AnchorPoint
    def removeBody1Axis(self, body1Axis):
        self.__body1Axis = [x for x in self.__body1Axis if x not in body1Axis]
        return self.__body1Axis
    def getBody1Axis(self, body1Axis = None):
        return self.__body1Axis
    def body1Axis_changed(self, body1Axis = None):
        return self.__body1Axis
    @property
    def body2(self):
        return self.__body2
    @body2.setter
    def body2(self, value = None):
        self.__body2 = [value]
    def setBody2(self, body2 = None):
        self.__body2 = [body2]
        return self
    def addBody2(self, body2 = None):
        if self.__body2 == None:            self.__body2 =  []
        self.__body2 +=  [body2]
        return self
    def removeBody2(self, body2):
        self.__body2 = [x for x in self.__body2 if x not in body2]
        return self.__body2
    def getBody2(self, body2 = None):
        return self.__body2
    def body2_changed(self, body2 = None):
        return self.__body2
    def removeBody2AnchorPoint(self, body2AnchorPoint):
        self.__body2AnchorPoint = [x for x in self.__body2AnchorPoint if x not in body2AnchorPoint]
        return self.__body2AnchorPoint
    def getBody2AnchorPoint(self, body2AnchorPoint = None):
        return self.__body2AnchorPoint
    def body2AnchorPoint_changed(self, body2AnchorPoint = None):
        return self.__body2AnchorPoint
    def removeBody2Axis(self, body2Axis):
        self.__body2Axis = [x for x in self.__body2Axis if x not in body2Axis]
        return self.__body2Axis
    def getBody2Axis(self, body2Axis = None):
        return self.__body2Axis
    def body2Axis_changed(self, body2Axis = None):
        return self.__body2Axis
    @property
    def forceOutput(self):
        return self.__forceOutput
    @forceOutput.setter
    def forceOutput(self, value = ["NONE"]):
        self.__forceOutput = [value]
    def setForceOutput(self, forceOutput = ["NONE"]):
        self.__forceOutput = [forceOutput]
        return self
    def addForceOutput(self, forceOutput = ["NONE"]):
        if self.__forceOutput == None:            self.__forceOutput =  []
        self.__forceOutput +=  [forceOutput]
        return self
    def removeForceOutput(self, forceOutput):
        self.__forceOutput = [x for x in self.__forceOutput if x not in forceOutput]
        return self.__forceOutput
    def getForceOutput(self, forceOutput = ["NONE"]):
        return self.__forceOutput
    def forceOutput_changed(self, forceOutput = ["NONE"]):
        return self.__forceOutput
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def stop1Bounce(self):
        return self.__stop1Bounce
    @stop1Bounce.setter
    def stop1Bounce(self, value = 0):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__stop1Bounce = [value]
    def setStop1Bounce(self, stop1Bounce = 0):
        if stop1Bounce == None or stop1Bounce  <  0:
            return None
        if stop1Bounce == None or stop1Bounce  >  1:
            return None
        self.__stop1Bounce = [stop1Bounce]
        return self
    def addStop1Bounce(self, stop1Bounce = 0):
        if stop1Bounce == None or stop1Bounce  <  0:
            return None
        if stop1Bounce == None or stop1Bounce  >  1:
            return None
        if self.__stop1Bounce == None:            self.__stop1Bounce =  []
        self.__stop1Bounce +=  [stop1Bounce]
        return self
    def removeStop1Bounce(self, stop1Bounce):
        self.__stop1Bounce = [x for x in self.__stop1Bounce if x not in stop1Bounce]
        return self.__stop1Bounce
    def getStop1Bounce(self, stop1Bounce = 0):
        return self.__stop1Bounce
    def stop1Bounce_changed(self, stop1Bounce = 0):
        return self.__stop1Bounce
    @property
    def stop1ErrorCorrection(self):
        return self.__stop1ErrorCorrection
    @stop1ErrorCorrection.setter
    def stop1ErrorCorrection(self, value = 0.8):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__stop1ErrorCorrection = [value]
    def setStop1ErrorCorrection(self, stop1ErrorCorrection = 0.8):
        if stop1ErrorCorrection == None or stop1ErrorCorrection  <  0:
            return None
        if stop1ErrorCorrection == None or stop1ErrorCorrection  >  1:
            return None
        self.__stop1ErrorCorrection = [stop1ErrorCorrection]
        return self
    def addStop1ErrorCorrection(self, stop1ErrorCorrection = 0.8):
        if stop1ErrorCorrection == None or stop1ErrorCorrection  <  0:
            return None
        if stop1ErrorCorrection == None or stop1ErrorCorrection  >  1:
            return None
        if self.__stop1ErrorCorrection == None:            self.__stop1ErrorCorrection =  []
        self.__stop1ErrorCorrection +=  [stop1ErrorCorrection]
        return self
    def removeStop1ErrorCorrection(self, stop1ErrorCorrection):
        self.__stop1ErrorCorrection = [x for x in self.__stop1ErrorCorrection if x not in stop1ErrorCorrection]
        return self.__stop1ErrorCorrection
    def getStop1ErrorCorrection(self, stop1ErrorCorrection = 0.8):
        return self.__stop1ErrorCorrection
    def stop1ErrorCorrection_changed(self, stop1ErrorCorrection = 0.8):
        return self.__stop1ErrorCorrection
    @property
    def stop2Bounce(self):
        return self.__stop2Bounce
    @stop2Bounce.setter
    def stop2Bounce(self, value = 0):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__stop2Bounce = [value]
    def setStop2Bounce(self, stop2Bounce = 0):
        if stop2Bounce == None or stop2Bounce  <  0:
            return None
        if stop2Bounce == None or stop2Bounce  >  1:
            return None
        self.__stop2Bounce = [stop2Bounce]
        return self
    def addStop2Bounce(self, stop2Bounce = 0):
        if stop2Bounce == None or stop2Bounce  <  0:
            return None
        if stop2Bounce == None or stop2Bounce  >  1:
            return None
        if self.__stop2Bounce == None:            self.__stop2Bounce =  []
        self.__stop2Bounce +=  [stop2Bounce]
        return self
    def removeStop2Bounce(self, stop2Bounce):
        self.__stop2Bounce = [x for x in self.__stop2Bounce if x not in stop2Bounce]
        return self.__stop2Bounce
    def getStop2Bounce(self, stop2Bounce = 0):
        return self.__stop2Bounce
    def stop2Bounce_changed(self, stop2Bounce = 0):
        return self.__stop2Bounce
    @property
    def stop2ErrorCorrection(self):
        return self.__stop2ErrorCorrection
    @stop2ErrorCorrection.setter
    def stop2ErrorCorrection(self, value = 0.8):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__stop2ErrorCorrection = [value]
    def setStop2ErrorCorrection(self, stop2ErrorCorrection = 0.8):
        if stop2ErrorCorrection == None or stop2ErrorCorrection  <  0:
            return None
        if stop2ErrorCorrection == None or stop2ErrorCorrection  >  1:
            return None
        self.__stop2ErrorCorrection = [stop2ErrorCorrection]
        return self
    def addStop2ErrorCorrection(self, stop2ErrorCorrection = 0.8):
        if stop2ErrorCorrection == None or stop2ErrorCorrection  <  0:
            return None
        if stop2ErrorCorrection == None or stop2ErrorCorrection  >  1:
            return None
        if self.__stop2ErrorCorrection == None:            self.__stop2ErrorCorrection =  []
        self.__stop2ErrorCorrection +=  [stop2ErrorCorrection]
        return self
    def removeStop2ErrorCorrection(self, stop2ErrorCorrection):
        self.__stop2ErrorCorrection = [x for x in self.__stop2ErrorCorrection if x not in stop2ErrorCorrection]
        return self.__stop2ErrorCorrection
    def getStop2ErrorCorrection(self, stop2ErrorCorrection = 0.8):
        return self.__stop2ErrorCorrection
    def stop2ErrorCorrection_changed(self, stop2ErrorCorrection = 0.8):
        return self.__stop2ErrorCorrection
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<UniversalJoint'
        if self.__anchorPoint is not None:
            if isinstance(self.__anchorPoint, six.string_types):
                str += ' anchorPoint="'+self.__anchorPoint+'"'
            else:
                str += ' anchorPoint="'+self.__anchorPoint[0]+'"'
        if self.__axis1 is not None:
            if isinstance(self.__axis1, six.string_types):
                str += ' axis1="'+self.__axis1+'"'
            else:
                str += ' axis1="'+self.__axis1[0]+'"'
        if self.__axis2 is not None:
            if isinstance(self.__axis2, six.string_types):
                str += ' axis2="'+self.__axis2+'"'
            else:
                str += ' axis2="'+self.__axis2[0]+'"'
        if self.__body1AnchorPoint is not None:
            if isinstance(self.__body1AnchorPoint, six.string_types):
                str += ' body1AnchorPoint="'+self.__body1AnchorPoint+'"'
            else:
                str += ' body1AnchorPoint="'+self.__body1AnchorPoint[0]+'"'
        if self.__body1Axis is not None:
            if isinstance(self.__body1Axis, six.string_types):
                str += ' body1Axis="'+self.__body1Axis+'"'
            else:
                str += ' body1Axis="'+self.__body1Axis[0]+'"'
        if self.__body2AnchorPoint is not None:
            if isinstance(self.__body2AnchorPoint, six.string_types):
                str += ' body2AnchorPoint="'+self.__body2AnchorPoint+'"'
            else:
                str += ' body2AnchorPoint="'+self.__body2AnchorPoint[0]+'"'
        if self.__body2Axis is not None:
            if isinstance(self.__body2Axis, six.string_types):
                str += ' body2Axis="'+self.__body2Axis+'"'
            else:
                str += ' body2Axis="'+self.__body2Axis[0]+'"'
        if self.__forceOutput is not None:
            if isinstance(self.__forceOutput, six.string_types):
                str += ' forceOutput="'+self.__forceOutput+'"'
            else:
                str += ' forceOutput="'+self.__forceOutput[0]+'"'
        if self.__stop1Bounce is not None:
            if isinstance(self.__stop1Bounce, six.string_types):
                str += ' stop1Bounce="'+self.__stop1Bounce+'"'
            else:
                str += ' stop1Bounce="'+self.__stop1Bounce[0]+'"'
        if self.__stop1ErrorCorrection is not None:
            if isinstance(self.__stop1ErrorCorrection, six.string_types):
                str += ' stop1ErrorCorrection="'+self.__stop1ErrorCorrection+'"'
            else:
                str += ' stop1ErrorCorrection="'+self.__stop1ErrorCorrection[0]+'"'
        if self.__stop2Bounce is not None:
            if isinstance(self.__stop2Bounce, six.string_types):
                str += ' stop2Bounce="'+self.__stop2Bounce+'"'
            else:
                str += ' stop2Bounce="'+self.__stop2Bounce[0]+'"'
        if self.__stop2ErrorCorrection is not None:
            if isinstance(self.__stop2ErrorCorrection, six.string_types):
                str += ' stop2ErrorCorrection="'+self.__stop2ErrorCorrection+'"'
            else:
                str += ' stop2ErrorCorrection="'+self.__stop2ErrorCorrection[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<body1'
        if self.__body1 is not None:
           for s in self.__body1:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__body1 is not None:
           for s in self.__body1:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</body1>'
        str += '<body2'
        if self.__body2 is not None:
           for s in self.__body2:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__body2 is not None:
           for s in self.__body2:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</body2>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</UniversalJoint>'
        return str


class Viewpoint(X3DViewpointNode):
    def __init__(self, **kwargs):
        super(Viewpoint, self).__init__(**kwargs)
        bindTime  = kwargs.pop("bindTime", None)
        self.__bindTime = bindTime
        centerOfRotation  = kwargs.pop("centerOfRotation", [0, 0, 0])
        self.__centerOfRotation = centerOfRotation
        description  = kwargs.pop("description", None)
        self.__description = description
        fieldOfView  = kwargs.pop("fieldOfView", 0.7854)
        if fieldOfView == None or fieldOfView  <=  0:
            return None
        if fieldOfView == None or fieldOfView  >=  3.1416:
            return None
        self.__fieldOfView = fieldOfView
        Bound  = kwargs.pop("Bound", None)
        self.__Bound = Bound
        jump  = kwargs.pop("jump", True)
        self.__jump = jump
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        orientation  = kwargs.pop("orientation", [0, 0, 1, 0])
        self.__orientation = orientation
        position  = kwargs.pop("position", [0, 0, 10])
        self.__position = position
        retainUserOffsets  = kwargs.pop("retainUserOffsets", False)
        self.__retainUserOffsets = retainUserOffsets
        bind  = kwargs.pop("bind", None)
        self.__bind = bind
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    def removeBindTime(self, bindTime):
        self.__bindTime = [x for x in self.__bindTime if x not in bindTime]
        return self.__bindTime
    def getBindTime(self, bindTime = None):
        return self.__bindTime
    def bindTime_changed(self, bindTime = None):
        return self.__bindTime
    @property
    def centerOfRotation(self):
        return self.__centerOfRotation
    @centerOfRotation.setter
    def centerOfRotation(self, value = [0, 0, 0]):
        self.__centerOfRotation = [value]
    def setCenterOfRotation(self, centerOfRotation = [0, 0, 0]):
        self.__centerOfRotation = [centerOfRotation]
        return self
    def addCenterOfRotation(self, centerOfRotation = [0, 0, 0]):
        if self.__centerOfRotation == None:            self.__centerOfRotation =  []
        self.__centerOfRotation +=  [centerOfRotation]
        return self
    def removeCenterOfRotation(self, centerOfRotation):
        self.__centerOfRotation = [x for x in self.__centerOfRotation if x not in centerOfRotation]
        return self.__centerOfRotation
    def getCenterOfRotation(self, centerOfRotation = [0, 0, 0]):
        return self.__centerOfRotation
    def centerOfRotation_changed(self, centerOfRotation = [0, 0, 0]):
        return self.__centerOfRotation
    @property
    def description(self):
        return self.__description
    @description.setter
    def description(self, value = None):
        self.__description = [value]
    def setDescription(self, description = None):
        self.__description = [description]
        return self
    def addDescription(self, description = None):
        if self.__description == None:            self.__description =  []
        self.__description +=  [description]
        return self
    def removeDescription(self, description):
        self.__description = [x for x in self.__description if x not in description]
        return self.__description
    def getDescription(self, description = None):
        return self.__description
    def description_changed(self, description = None):
        return self.__description
    @property
    def fieldOfView(self):
        return self.__fieldOfView
    @fieldOfView.setter
    def fieldOfView(self, value = 0.7854):
        if value == None or value  <=  0:
            return None
        if value == None or value  >=  3.1416:
            return None
        self.__fieldOfView = [value]
    def setFieldOfView(self, fieldOfView = 0.7854):
        if fieldOfView == None or fieldOfView  <=  0:
            return None
        if fieldOfView == None or fieldOfView  >=  3.1416:
            return None
        self.__fieldOfView = [fieldOfView]
        return self
    def addFieldOfView(self, fieldOfView = 0.7854):
        if fieldOfView == None or fieldOfView  <=  0:
            return None
        if fieldOfView == None or fieldOfView  >=  3.1416:
            return None
        if self.__fieldOfView == None:            self.__fieldOfView =  []
        self.__fieldOfView +=  [fieldOfView]
        return self
    def removeFieldOfView(self, fieldOfView):
        self.__fieldOfView = [x for x in self.__fieldOfView if x not in fieldOfView]
        return self.__fieldOfView
    def getFieldOfView(self, fieldOfView = 0.7854):
        return self.__fieldOfView
    def fieldOfView_changed(self, fieldOfView = 0.7854):
        return self.__fieldOfView
    def isBound(self, Bound = None):
        return self.__Bound
    @property
    def jump(self):
        return self.__jump
    @jump.setter
    def jump(self, value = True):
        self.__jump = [value]
    def setJump(self, jump = True):
        self.__jump = [jump]
        return self
    def addJump(self, jump = True):
        if self.__jump == None:            self.__jump =  []
        self.__jump +=  [jump]
        return self
    def removeJump(self, jump):
        self.__jump = [x for x in self.__jump if x not in jump]
        return self.__jump
    def isJump(self, jump = True):
        return self.__jump
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def orientation(self):
        return self.__orientation
    @orientation.setter
    def orientation(self, value = [0, 0, 1, 0]):
        self.__orientation = [value]
    def setOrientation(self, orientation = [0, 0, 1, 0]):
        self.__orientation = [orientation]
        return self
    def addOrientation(self, orientation = [0, 0, 1, 0]):
        if self.__orientation == None:            self.__orientation =  []
        self.__orientation +=  [orientation]
        return self
    def removeOrientation(self, orientation):
        self.__orientation = [x for x in self.__orientation if x not in orientation]
        return self.__orientation
    def getOrientation(self, orientation = [0, 0, 1, 0]):
        return self.__orientation
    def orientation_changed(self, orientation = [0, 0, 1, 0]):
        return self.__orientation
    @property
    def position(self):
        return self.__position
    @position.setter
    def position(self, value = [0, 0, 10]):
        self.__position = [value]
    def setPosition(self, position = [0, 0, 10]):
        self.__position = [position]
        return self
    def addPosition(self, position = [0, 0, 10]):
        if self.__position == None:            self.__position =  []
        self.__position +=  [position]
        return self
    def removePosition(self, position):
        self.__position = [x for x in self.__position if x not in position]
        return self.__position
    def getPosition(self, position = [0, 0, 10]):
        return self.__position
    def position_changed(self, position = [0, 0, 10]):
        return self.__position
    @property
    def retainUserOffsets(self):
        return self.__retainUserOffsets
    @retainUserOffsets.setter
    def retainUserOffsets(self, value = False):
        self.__retainUserOffsets = [value]
    def setRetainUserOffsets(self, retainUserOffsets = False):
        self.__retainUserOffsets = [retainUserOffsets]
        return self
    def addRetainUserOffsets(self, retainUserOffsets = False):
        if self.__retainUserOffsets == None:            self.__retainUserOffsets =  []
        self.__retainUserOffsets +=  [retainUserOffsets]
        return self
    def removeRetainUserOffsets(self, retainUserOffsets):
        self.__retainUserOffsets = [x for x in self.__retainUserOffsets if x not in retainUserOffsets]
        return self.__retainUserOffsets
    def isRetainUserOffsets(self, retainUserOffsets = False):
        return self.__retainUserOffsets
    @property
    def bind(self):
        return self.__bind
    @bind.setter
    def bind(self, value = None):
        self.__bind = [value]
    def set_bind(self, bind = None):
        self.__bind = [bind]
        return self
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    @property
    def IS(self):
        return self.__IS
    @IS.setter
    def IS(self, value = None):
        self.__IS = [value]
    def setIS(self, IS = None):
        self.__IS = [IS]
        return self
    def addIS(self, IS = None):
        if self.__IS == None:            self.__IS =  []
        self.__IS +=  [IS]
        return self
    def removeIS(self, IS):
        self.__IS = [x for x in self.__IS if x not in IS]
        return self.__IS
    def getIS(self, IS = None):
        return self.__IS
    def IS_changed(self, IS = None):
        return self.__IS
    def toXML(self):
        str = ''
        str += '<Viewpoint'
        if self.__bindTime is not None:
            if isinstance(self.__bindTime, six.string_types):
                str += ' bindTime="'+self.__bindTime+'"'
            else:
                str += ' bindTime="'+self.__bindTime[0]+'"'
        if self.__centerOfRotation is not None:
            if isinstance(self.__centerOfRotation, six.string_types):
                str += ' centerOfRotation="'+self.__centerOfRotation+'"'
            else:
                str += ' centerOfRotation="'+self.__centerOfRotation[0]+'"'
        if self.__description is not None:
            if isinstance(self.__description, six.string_types):
                str += ' description="'+self.__description+'"'
            else:
                str += ' description="'+self.__description[0]+'"'
        if self.__fieldOfView is not None:
            if isinstance(self.__fieldOfView, six.string_types):
                str += ' fieldOfView="'+self.__fieldOfView+'"'
            else:
                str += ' fieldOfView="'+self.__fieldOfView[0]+'"'
        if self.__Bound is not None:
            if isinstance(self.__Bound, six.string_types):
                str += ' Bound="'+self.__Bound+'"'
            else:
                str += ' Bound="'+self.__Bound[0]+'"'
        if self.__jump is not None:
            if isinstance(self.__jump, six.string_types):
                str += ' jump="'+self.__jump+'"'
            else:
                str += ' jump="'+self.__jump[0]+'"'
        if self.__orientation is not None:
            if isinstance(self.__orientation, six.string_types):
                str += ' orientation="'+self.__orientation+'"'
            else:
                str += ' orientation="'+self.__orientation[0]+'"'
        if self.__position is not None:
            if isinstance(self.__position, six.string_types):
                str += ' position="'+self.__position+'"'
            else:
                str += ' position="'+self.__position[0]+'"'
        if self.__retainUserOffsets is not None:
            if isinstance(self.__retainUserOffsets, six.string_types):
                str += ' retainUserOffsets="'+self.__retainUserOffsets+'"'
            else:
                str += ' retainUserOffsets="'+self.__retainUserOffsets[0]+'"'
        if self.__bind is not None:
            if isinstance(self.__bind, six.string_types):
                str += ' bind="'+self.__bind+'"'
            else:
                str += ' bind="'+self.__bind[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</Viewpoint>'
        return str


class ViewpointGroup(X3DChildNode):
    def __init__(self, **kwargs):
        super(ViewpointGroup, self).__init__(**kwargs)
        center  = kwargs.pop("center", [0, 0, 0])
        self.__center = center
        children  = kwargs.pop("children", None)
        self.__children = children
        description  = kwargs.pop("description", None)
        self.__description = description
        displayed  = kwargs.pop("displayed", True)
        self.__displayed = displayed
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        retainUserOffsets  = kwargs.pop("retainUserOffsets", False)
        self.__retainUserOffsets = retainUserOffsets
        size  = kwargs.pop("size", [0, 0, 0])
        self.__size = size
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def center(self):
        return self.__center
    @center.setter
    def center(self, value = [0, 0, 0]):
        self.__center = [value]
    def setCenter(self, center = [0, 0, 0]):
        self.__center = [center]
        return self
    def addCenter(self, center = [0, 0, 0]):
        if self.__center == None:            self.__center =  []
        self.__center +=  [center]
        return self
    def removeCenter(self, center):
        self.__center = [x for x in self.__center if x not in center]
        return self.__center
    def getCenter(self, center = [0, 0, 0]):
        return self.__center
    def center_changed(self, center = [0, 0, 0]):
        return self.__center
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    @property
    def description(self):
        return self.__description
    @description.setter
    def description(self, value = None):
        self.__description = [value]
    def setDescription(self, description = None):
        self.__description = [description]
        return self
    def addDescription(self, description = None):
        if self.__description == None:            self.__description =  []
        self.__description +=  [description]
        return self
    def removeDescription(self, description):
        self.__description = [x for x in self.__description if x not in description]
        return self.__description
    def getDescription(self, description = None):
        return self.__description
    def description_changed(self, description = None):
        return self.__description
    @property
    def displayed(self):
        return self.__displayed
    @displayed.setter
    def displayed(self, value = True):
        self.__displayed = [value]
    def setDisplayed(self, displayed = True):
        self.__displayed = [displayed]
        return self
    def addDisplayed(self, displayed = True):
        if self.__displayed == None:            self.__displayed =  []
        self.__displayed +=  [displayed]
        return self
    def removeDisplayed(self, displayed):
        self.__displayed = [x for x in self.__displayed if x not in displayed]
        return self.__displayed
    def isDisplayed(self, displayed = True):
        return self.__displayed
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def retainUserOffsets(self):
        return self.__retainUserOffsets
    @retainUserOffsets.setter
    def retainUserOffsets(self, value = False):
        self.__retainUserOffsets = [value]
    def setRetainUserOffsets(self, retainUserOffsets = False):
        self.__retainUserOffsets = [retainUserOffsets]
        return self
    def addRetainUserOffsets(self, retainUserOffsets = False):
        if self.__retainUserOffsets == None:            self.__retainUserOffsets =  []
        self.__retainUserOffsets +=  [retainUserOffsets]
        return self
    def removeRetainUserOffsets(self, retainUserOffsets):
        self.__retainUserOffsets = [x for x in self.__retainUserOffsets if x not in retainUserOffsets]
        return self.__retainUserOffsets
    def isRetainUserOffsets(self, retainUserOffsets = False):
        return self.__retainUserOffsets
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ViewpointGroup'
        if self.__center is not None:
            if isinstance(self.__center, six.string_types):
                str += ' center="'+self.__center+'"'
            else:
                str += ' center="'+self.__center[0]+'"'
        if self.__description is not None:
            if isinstance(self.__description, six.string_types):
                str += ' description="'+self.__description+'"'
            else:
                str += ' description="'+self.__description[0]+'"'
        if self.__displayed is not None:
            if isinstance(self.__displayed, six.string_types):
                str += ' displayed="'+self.__displayed+'"'
            else:
                str += ' displayed="'+self.__displayed[0]+'"'
        if self.__retainUserOffsets is not None:
            if isinstance(self.__retainUserOffsets, six.string_types):
                str += ' retainUserOffsets="'+self.__retainUserOffsets+'"'
            else:
                str += ' retainUserOffsets="'+self.__retainUserOffsets[0]+'"'
        if self.__size is not None:
            if isinstance(self.__size, six.string_types):
                str += ' size="'+self.__size+'"'
            else:
                str += ' size="'+self.__size[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</ViewpointGroup>'
        return str


class Viewport(X3DViewportNode):
    def __init__(self, **kwargs):
        super(Viewport, self).__init__(**kwargs)
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        children  = kwargs.pop("children", None)
        self.__children = children
        clipBoundary  = kwargs.pop("clipBoundary", [0, 1, 0, 1])
        if clipBoundary == None or len(clipBoundary) <= 0 or min(clipBoundary)  <  0:
            return None
        if clipBoundary == None or len(clipBoundary) <= 0 or max(clipBoundary)  >  1:
            return None
        self.__clipBoundary = clipBoundary
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        Children  = kwargs.pop("Children", None)
        self.__children = Children
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    def addChildren(self, Children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [Children]
        return self
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    @property
    def clipBoundary(self):
        return self.__clipBoundary
    @clipBoundary.setter
    def clipBoundary(self, value = [0, 1, 0, 1]):
        if value == None or len(value) <= 0 or min(value)  <  0:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__clipBoundary = [value]
    def setClipBoundary(self, clipBoundary = [0, 1, 0, 1]):
        if clipBoundary == None or len(clipBoundary) <= 0 or min(clipBoundary)  <  0:
            return None
        if clipBoundary == None or len(clipBoundary) <= 0 or max(clipBoundary)  >  1:
            return None
        self.__clipBoundary = [clipBoundary]
        return self
    def addClipBoundary(self, clipBoundary = [0, 1, 0, 1]):
        if clipBoundary == None or len(clipBoundary) <= 0 or min(clipBoundary)  <  0:
            return None
        if clipBoundary == None or len(clipBoundary) <= 0 or max(clipBoundary)  >  1:
            return None
        if self.__clipBoundary == None:            self.__clipBoundary =  []
        self.__clipBoundary +=  [clipBoundary]
        return self
    def removeClipBoundary(self, clipBoundary):
        self.__clipBoundary = [x for x in self.__clipBoundary if x not in clipBoundary]
        return self.__clipBoundary
    def getClipBoundary(self, clipBoundary = [0, 1, 0, 1]):
        return self.__clipBoundary
    def clipBoundary_changed(self, clipBoundary = [0, 1, 0, 1]):
        return self.__clipBoundary
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def Children(self):
        return self.__children
    @Children.setter
    def Children(self, value = None):
        self.__children = [value]
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<Viewport'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__clipBoundary is not None:
            if isinstance(self.__clipBoundary, six.string_types):
                str += ' clipBoundary="'+self.__clipBoundary+'"'
            else:
                str += ' clipBoundary="'+self.__clipBoundary[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<Children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Children>'
        str += '</Viewport>'
        return str


class VisibilitySensor(X3DEnvironmentalSensorNode):
    def __init__(self, **kwargs):
        super(VisibilitySensor, self).__init__(**kwargs)
        center  = kwargs.pop("center", [0, 0, 0])
        self.__center = center
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        enterTime  = kwargs.pop("enterTime", None)
        self.__enterTime = enterTime
        exitTime  = kwargs.pop("exitTime", None)
        self.__exitTime = exitTime
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        size  = kwargs.pop("size", [0, 0, 0])
        if size == None or len(size) <= 0 or min(size)  <  0:
            return None
        self.__size = size
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def center(self):
        return self.__center
    @center.setter
    def center(self, value = [0, 0, 0]):
        self.__center = [value]
    def setCenter(self, center = [0, 0, 0]):
        self.__center = [center]
        return self
    def addCenter(self, center = [0, 0, 0]):
        if self.__center == None:            self.__center =  []
        self.__center +=  [center]
        return self
    def removeCenter(self, center):
        self.__center = [x for x in self.__center if x not in center]
        return self.__center
    def getCenter(self, center = [0, 0, 0]):
        return self.__center
    def center_changed(self, center = [0, 0, 0]):
        return self.__center
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    def removeEnterTime(self, enterTime):
        self.__enterTime = [x for x in self.__enterTime if x not in enterTime]
        return self.__enterTime
    def getEnterTime(self, enterTime = None):
        return self.__enterTime
    def enterTime_changed(self, enterTime = None):
        return self.__enterTime
    def removeExitTime(self, exitTime):
        self.__exitTime = [x for x in self.__exitTime if x not in exitTime]
        return self.__exitTime
    def getExitTime(self, exitTime = None):
        return self.__exitTime
    def exitTime_changed(self, exitTime = None):
        return self.__exitTime
    def isActive(self, Active = None):
        return self.__Active
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<VisibilitySensor'
        if self.__center is not None:
            if isinstance(self.__center, six.string_types):
                str += ' center="'+self.__center+'"'
            else:
                str += ' center="'+self.__center[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__enterTime is not None:
            if isinstance(self.__enterTime, six.string_types):
                str += ' enterTime="'+self.__enterTime+'"'
            else:
                str += ' enterTime="'+self.__enterTime[0]+'"'
        if self.__exitTime is not None:
            if isinstance(self.__exitTime, six.string_types):
                str += ' exitTime="'+self.__exitTime+'"'
            else:
                str += ' exitTime="'+self.__exitTime[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__size is not None:
            if isinstance(self.__size, six.string_types):
                str += ' size="'+self.__size+'"'
            else:
                str += ' size="'+self.__size[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</VisibilitySensor>'
        return str


class VolumeData(X3DVolumeDataNode):
    def __init__(self, **kwargs):
        super(VolumeData, self).__init__(**kwargs)
        bboxCenter  = kwargs.pop("bboxCenter", [0, 0, 0])
        self.__bboxCenter = bboxCenter
        bboxSize  = kwargs.pop("bboxSize", [-1, -1, -1])
        self.__bboxSize = bboxSize
        dimensions  = kwargs.pop("dimensions", [1, 1, 1])
        if dimensions == None or len(dimensions) <= 0 or min(dimensions)  <=  0:
            return None
        self.__dimensions = dimensions
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        renderStyle  = kwargs.pop("renderStyle", None)
        self.__renderStyle = renderStyle
        voxels  = kwargs.pop("voxels", None)
        self.__voxels = voxels
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def dimensions(self):
        return self.__dimensions
    @dimensions.setter
    def dimensions(self, value = [1, 1, 1]):
        if value == None or len(value) <= 0 or min(value)  <=  0:
            return None
        self.__dimensions = [value]
    def setDimensions(self, dimensions = [1, 1, 1]):
        if dimensions == None or len(dimensions) <= 0 or min(dimensions)  <=  0:
            return None
        self.__dimensions = [dimensions]
        return self
    def addDimensions(self, dimensions = [1, 1, 1]):
        if dimensions == None or len(dimensions) <= 0 or min(dimensions)  <=  0:
            return None
        if self.__dimensions == None:            self.__dimensions =  []
        self.__dimensions +=  [dimensions]
        return self
    def removeDimensions(self, dimensions):
        self.__dimensions = [x for x in self.__dimensions if x not in dimensions]
        return self.__dimensions
    def getDimensions(self, dimensions = [1, 1, 1]):
        return self.__dimensions
    def dimensions_changed(self, dimensions = [1, 1, 1]):
        return self.__dimensions
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def renderStyle(self):
        return self.__renderStyle
    @renderStyle.setter
    def renderStyle(self, value = None):
        self.__renderStyle = [value]
    def setRenderStyle(self, renderStyle = None):
        self.__renderStyle = [renderStyle]
        return self
    def addRenderStyle(self, renderStyle = None):
        if self.__renderStyle == None:            self.__renderStyle =  []
        self.__renderStyle +=  [renderStyle]
        return self
    def removeRenderStyle(self, renderStyle):
        self.__renderStyle = [x for x in self.__renderStyle if x not in renderStyle]
        return self.__renderStyle
    def getRenderStyle(self, renderStyle = None):
        return self.__renderStyle
    def renderStyle_changed(self, renderStyle = None):
        return self.__renderStyle
    @property
    def voxels(self):
        return self.__voxels
    @voxels.setter
    def voxels(self, value = None):
        self.__voxels = [value]
    def setVoxels(self, voxels = None):
        self.__voxels = [voxels]
        return self
    def addVoxels(self, voxels = None):
        if self.__voxels == None:            self.__voxels =  []
        self.__voxels +=  [voxels]
        return self
    def removeVoxels(self, voxels):
        self.__voxels = [x for x in self.__voxels if x not in voxels]
        return self.__voxels
    def getVoxels(self, voxels = None):
        return self.__voxels
    def voxels_changed(self, voxels = None):
        return self.__voxels
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<VolumeData'
        if self.__bboxCenter is not None:
            if isinstance(self.__bboxCenter, six.string_types):
                str += ' bboxCenter="'+self.__bboxCenter+'"'
            else:
                str += ' bboxCenter="'+self.__bboxCenter[0]+'"'
        if self.__bboxSize is not None:
            if isinstance(self.__bboxSize, six.string_types):
                str += ' bboxSize="'+self.__bboxSize+'"'
            else:
                str += ' bboxSize="'+self.__bboxSize[0]+'"'
        if self.__dimensions is not None:
            if isinstance(self.__dimensions, six.string_types):
                str += ' dimensions="'+self.__dimensions+'"'
            else:
                str += ' dimensions="'+self.__dimensions[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<renderStyle'
        if self.__renderStyle is not None:
           for s in self.__renderStyle:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__renderStyle is not None:
           for s in self.__renderStyle:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</renderStyle>'
        str += '<voxels'
        if self.__voxels is not None:
           for s in self.__voxels:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__voxels is not None:
           for s in self.__voxels:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</voxels>'
        str += '</VolumeData>'
        return str


class VolumeEmitter(X3DParticleEmitterNode):
    def __init__(self, **kwargs):
        super(VolumeEmitter, self).__init__(**kwargs)
        coord  = kwargs.pop("coord", None)
        self.__coord = coord
        coordIndex  = kwargs.pop("coordIndex", [-1])
        if coordIndex == None or len(coordIndex) <= 0 or min(coordIndex)  <  -1:
            return None
        self.__coordIndex = coordIndex
        direction  = kwargs.pop("direction", [0, 1, 0])
        if direction == None or len(direction) <= 0 or min(direction)  <  -1:
            return None
        if direction == None or len(direction) <= 0 or max(direction)  >  1:
            return None
        self.__direction = direction
        internal  = kwargs.pop("internal", True)
        self.__internal = internal
        mass  = kwargs.pop("mass", 0)
        if mass == None or mass  <  0:
            return None
        self.__mass = mass
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        coordIndex  = kwargs.pop("coordIndex", None)
        if coordIndex == None or len(coordIndex) <= 0 or min(coordIndex)  <  -1:
            return None
        self.__coordIndex = coordIndex
        speed  = kwargs.pop("speed", 0)
        if speed == None or speed  <  0:
            return None
        self.__speed = speed
        surfaceArea  = kwargs.pop("surfaceArea", 0)
        if surfaceArea == None or surfaceArea  <  0:
            return None
        self.__surfaceArea = surfaceArea
        variation  = kwargs.pop("variation", 0.25)
        if variation == None or variation  <  0:
            return None
        self.__variation = variation
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def coord(self):
        return self.__coord
    @coord.setter
    def coord(self, value = None):
        self.__coord = [value]
    def setCoord(self, coord = None):
        self.__coord = [coord]
        return self
    def addCoord(self, coord = None):
        if self.__coord == None:            self.__coord =  []
        self.__coord +=  [coord]
        return self
    def removeCoord(self, coord):
        self.__coord = [x for x in self.__coord if x not in coord]
        return self.__coord
    def getCoord(self, coord = None):
        return self.__coord
    def coord_changed(self, coord = None):
        return self.__coord
    @property
    def direction(self):
        return self.__direction
    @direction.setter
    def direction(self, value = [0, 1, 0]):
        if value == None or len(value) <= 0 or min(value)  <  -1:
            return None
        if value == None or len(value) <= 0 or max(value)  >  1:
            return None
        self.__direction = [value]
    def setDirection(self, direction = [0, 1, 0]):
        if direction == None or len(direction) <= 0 or min(direction)  <  -1:
            return None
        if direction == None or len(direction) <= 0 or max(direction)  >  1:
            return None
        self.__direction = [direction]
        return self
    def addDirection(self, direction = [0, 1, 0]):
        if direction == None or len(direction) <= 0 or min(direction)  <  -1:
            return None
        if direction == None or len(direction) <= 0 or max(direction)  >  1:
            return None
        if self.__direction == None:            self.__direction =  []
        self.__direction +=  [direction]
        return self
    def removeDirection(self, direction):
        self.__direction = [x for x in self.__direction if x not in direction]
        return self.__direction
    def getDirection(self, direction = [0, 1, 0]):
        return self.__direction
    def direction_changed(self, direction = [0, 1, 0]):
        return self.__direction
    @property
    def mass(self):
        return self.__mass
    @mass.setter
    def mass(self, value = 0):
        if value == None or value  <  0:
            return None
        self.__mass = [value]
    def setMass(self, mass = 0):
        if mass == None or mass  <  0:
            return None
        self.__mass = [mass]
        return self
    def addMass(self, mass = 0):
        if mass == None or mass  <  0:
            return None
        if self.__mass == None:            self.__mass =  []
        self.__mass +=  [mass]
        return self
    def removeMass(self, mass):
        self.__mass = [x for x in self.__mass if x not in mass]
        return self.__mass
    def getMass(self, mass = 0):
        return self.__mass
    def mass_changed(self, mass = 0):
        return self.__mass
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def coordIndex(self):
        return self.__coordIndex
    @coordIndex.setter
    def coordIndex(self, value = None):
        if value == None or len(value) <= 0 or min(value)  <  -1:
            return None
        self.__coordIndex = [value]
    def set_coordIndex(self, coordIndex = None):
        if coordIndex == None or len(coordIndex) <= 0 or min(coordIndex)  <  -1:
            return None
        self.__coordIndex = [coordIndex]
        return self
    @property
    def speed(self):
        return self.__speed
    @speed.setter
    def speed(self, value = 0):
        if value == None or value  <  0:
            return None
        self.__speed = [value]
    def setSpeed(self, speed = 0):
        if speed == None or speed  <  0:
            return None
        self.__speed = [speed]
        return self
    def addSpeed(self, speed = 0):
        if speed == None or speed  <  0:
            return None
        if self.__speed == None:            self.__speed =  []
        self.__speed +=  [speed]
        return self
    def removeSpeed(self, speed):
        self.__speed = [x for x in self.__speed if x not in speed]
        return self.__speed
    def getSpeed(self, speed = 0):
        return self.__speed
    def speed_changed(self, speed = 0):
        return self.__speed
    @property
    def variation(self):
        return self.__variation
    @variation.setter
    def variation(self, value = 0.25):
        if value == None or value  <  0:
            return None
        self.__variation = [value]
    def setVariation(self, variation = 0.25):
        if variation == None or variation  <  0:
            return None
        self.__variation = [variation]
        return self
    def addVariation(self, variation = 0.25):
        if variation == None or variation  <  0:
            return None
        if self.__variation == None:            self.__variation =  []
        self.__variation +=  [variation]
        return self
    def removeVariation(self, variation):
        self.__variation = [x for x in self.__variation if x not in variation]
        return self.__variation
    def getVariation(self, variation = 0.25):
        return self.__variation
    def variation_changed(self, variation = 0.25):
        return self.__variation
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<VolumeEmitter'
        if self.__coordIndex is not None:
            if isinstance(self.__coordIndex, six.string_types):
                str += ' coordIndex="'+self.__coordIndex+'"'
            else:
                str += ' coordIndex="'+self.__coordIndex[0]+'"'
        if self.__direction is not None:
            if isinstance(self.__direction, six.string_types):
                str += ' direction="'+self.__direction+'"'
            else:
                str += ' direction="'+self.__direction[0]+'"'
        if self.__internal is not None:
            if isinstance(self.__internal, six.string_types):
                str += ' internal="'+self.__internal+'"'
            else:
                str += ' internal="'+self.__internal[0]+'"'
        if self.__mass is not None:
            if isinstance(self.__mass, six.string_types):
                str += ' mass="'+self.__mass+'"'
            else:
                str += ' mass="'+self.__mass[0]+'"'
        if self.__coordIndex is not None:
            if isinstance(self.__coordIndex, six.string_types):
                str += ' coordIndex="'+self.__coordIndex+'"'
            else:
                str += ' coordIndex="'+self.__coordIndex[0]+'"'
        if self.__speed is not None:
            if isinstance(self.__speed, six.string_types):
                str += ' speed="'+self.__speed+'"'
            else:
                str += ' speed="'+self.__speed[0]+'"'
        if self.__surfaceArea is not None:
            if isinstance(self.__surfaceArea, six.string_types):
                str += ' surfaceArea="'+self.__surfaceArea+'"'
            else:
                str += ' surfaceArea="'+self.__surfaceArea[0]+'"'
        if self.__variation is not None:
            if isinstance(self.__variation, six.string_types):
                str += ' variation="'+self.__variation+'"'
            else:
                str += ' variation="'+self.__variation[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<coord'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__coord is not None:
           for s in self.__coord:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</coord>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</VolumeEmitter>'
        return str


class VolumePickSensor(X3DPickSensorNode):
    def __init__(self, **kwargs):
        super(VolumePickSensor, self).__init__(**kwargs)
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        intersectionType  = kwargs.pop("intersectionType", "BOUNDS")
        self.__intersectionType = intersectionType
        Active  = kwargs.pop("Active", None)
        self.__Active = Active
        matchCriterion  = kwargs.pop("matchCriterion", "MATCH_ANY")
        if 'MATCH_ANY' == matchCriterion:
            pass
        elif 'MATCH_EVERY' == matchCriterion:
            pass
        elif 'MATCH_ONLY_ONE' == matchCriterion:
            pass
        else:
            return None
        self.__matchCriterion = matchCriterion
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        objectType  = kwargs.pop("objectType", ["ALL"])
        self.__objectType = objectType
        pickedGeometry  = kwargs.pop("pickedGeometry", None)
        self.__pickedGeometry = pickedGeometry
        pickingGeometry  = kwargs.pop("pickingGeometry", None)
        self.__pickingGeometry = pickingGeometry
        pickTarget  = kwargs.pop("pickTarget", None)
        self.__pickTarget = pickTarget
        sortOrder  = kwargs.pop("sortOrder", "CLOSEST")
        self.__sortOrder = sortOrder
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    def isActive(self, Active = None):
        return self.__Active
    @property
    def matchCriterion(self):
        return self.__matchCriterion
    @matchCriterion.setter
    def matchCriterion(self, value = "MATCH_ANY"):
        if 'MATCH_ANY' == value:
            pass
        elif 'MATCH_EVERY' == value:
            pass
        elif 'MATCH_ONLY_ONE' == value:
            pass
        else:
            return None
        self.__matchCriterion = [value]
    def setMatchCriterion(self, matchCriterion = "MATCH_ANY"):
        if 'MATCH_ANY' == matchCriterion:
            pass
        elif 'MATCH_EVERY' == matchCriterion:
            pass
        elif 'MATCH_ONLY_ONE' == matchCriterion:
            pass
        else:
            return None
        self.__matchCriterion = [matchCriterion]
        return self
    def addMatchCriterion(self, matchCriterion = "MATCH_ANY"):
        if 'MATCH_ANY' == matchCriterion:
            pass
        elif 'MATCH_EVERY' == matchCriterion:
            pass
        elif 'MATCH_ONLY_ONE' == matchCriterion:
            pass
        else:
            return None
        if self.__matchCriterion == None:            self.__matchCriterion =  []
        self.__matchCriterion +=  [matchCriterion]
        return self
    def removeMatchCriterion(self, matchCriterion):
        self.__matchCriterion = [x for x in self.__matchCriterion if x not in matchCriterion]
        return self.__matchCriterion
    def getMatchCriterion(self, matchCriterion = "MATCH_ANY"):
        return self.__matchCriterion
    def matchCriterion_changed(self, matchCriterion = "MATCH_ANY"):
        return self.__matchCriterion
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def objectType(self):
        return self.__objectType
    @objectType.setter
    def objectType(self, value = ["ALL"]):
        self.__objectType = [value]
    def setObjectType(self, objectType = ["ALL"]):
        self.__objectType = [objectType]
        return self
    def addObjectType(self, objectType = ["ALL"]):
        if self.__objectType == None:            self.__objectType =  []
        self.__objectType +=  [objectType]
        return self
    def removeObjectType(self, objectType):
        self.__objectType = [x for x in self.__objectType if x not in objectType]
        return self.__objectType
    def getObjectType(self, objectType = ["ALL"]):
        return self.__objectType
    def objectType_changed(self, objectType = ["ALL"]):
        return self.__objectType
    def removePickedGeometry(self, pickedGeometry):
        self.__pickedGeometry = [x for x in self.__pickedGeometry if x not in pickedGeometry]
        return self.__pickedGeometry
    def getPickedGeometry(self, pickedGeometry = None):
        return self.__pickedGeometry
    def pickedGeometry_changed(self, pickedGeometry = None):
        return self.__pickedGeometry
    @property
    def pickingGeometry(self):
        return self.__pickingGeometry
    @pickingGeometry.setter
    def pickingGeometry(self, value = None):
        self.__pickingGeometry = [value]
    def setPickingGeometry(self, pickingGeometry = None):
        self.__pickingGeometry = [pickingGeometry]
        return self
    def addPickingGeometry(self, pickingGeometry = None):
        if self.__pickingGeometry == None:            self.__pickingGeometry =  []
        self.__pickingGeometry +=  [pickingGeometry]
        return self
    def removePickingGeometry(self, pickingGeometry):
        self.__pickingGeometry = [x for x in self.__pickingGeometry if x not in pickingGeometry]
        return self.__pickingGeometry
    def getPickingGeometry(self, pickingGeometry = None):
        return self.__pickingGeometry
    def pickingGeometry_changed(self, pickingGeometry = None):
        return self.__pickingGeometry
    @property
    def pickTarget(self):
        return self.__pickTarget
    @pickTarget.setter
    def pickTarget(self, value = None):
        self.__pickTarget = [value]
    def setPickTarget(self, pickTarget = None):
        self.__pickTarget = [pickTarget]
        return self
    def addPickTarget(self, pickTarget = None):
        if self.__pickTarget == None:            self.__pickTarget =  []
        self.__pickTarget +=  [pickTarget]
        return self
    def removePickTarget(self, pickTarget):
        self.__pickTarget = [x for x in self.__pickTarget if x not in pickTarget]
        return self.__pickTarget
    def getPickTarget(self, pickTarget = None):
        return self.__pickTarget
    def pickTarget_changed(self, pickTarget = None):
        return self.__pickTarget
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<VolumePickSensor'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__intersectionType is not None:
            if isinstance(self.__intersectionType, six.string_types):
                str += ' intersectionType="'+self.__intersectionType+'"'
            else:
                str += ' intersectionType="'+self.__intersectionType[0]+'"'
        if self.__Active is not None:
            if isinstance(self.__Active, six.string_types):
                str += ' Active="'+self.__Active+'"'
            else:
                str += ' Active="'+self.__Active[0]+'"'
        if self.__matchCriterion is not None:
            if isinstance(self.__matchCriterion, six.string_types):
                str += ' matchCriterion="'+self.__matchCriterion+'"'
            else:
                str += ' matchCriterion="'+self.__matchCriterion[0]+'"'
        if self.__objectType is not None:
            if isinstance(self.__objectType, six.string_types):
                str += ' objectType="'+self.__objectType+'"'
            else:
                str += ' objectType="'+self.__objectType[0]+'"'
        if self.__sortOrder is not None:
            if isinstance(self.__sortOrder, six.string_types):
                str += ' sortOrder="'+self.__sortOrder+'"'
            else:
                str += ' sortOrder="'+self.__sortOrder[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '<pickedGeometry'
        if self.__pickedGeometry is not None:
           for s in self.__pickedGeometry:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__pickedGeometry is not None:
           for s in self.__pickedGeometry:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</pickedGeometry>'
        str += '<pickingGeometry'
        if self.__pickingGeometry is not None:
           for s in self.__pickingGeometry:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__pickingGeometry is not None:
           for s in self.__pickingGeometry:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</pickingGeometry>'
        str += '<pickTarget'
        if self.__pickTarget is not None:
           for s in self.__pickTarget:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__pickTarget is not None:
           for s in self.__pickTarget:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</pickTarget>'
        str += '</VolumePickSensor>'
        return str


class WindPhysicsModel(X3DParticlePhysicsModelNode):
    def __init__(self, **kwargs):
        super(WindPhysicsModel, self).__init__(**kwargs)
        direction  = kwargs.pop("direction", [1, 0, 0])
        self.__direction = direction
        enabled  = kwargs.pop("enabled", True)
        self.__enabled = enabled
        gustiness  = kwargs.pop("gustiness", 0.1)
        if gustiness == None or gustiness  <  0:
            return None
        self.__gustiness = gustiness
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        speed  = kwargs.pop("speed", 0.1)
        if speed == None or speed  <  0:
            return None
        self.__speed = speed
        turbulence  = kwargs.pop("turbulence", 0)
        if turbulence == None or turbulence  <  0:
            return None
        if turbulence == None or turbulence  >  1:
            return None
        self.__turbulence = turbulence
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def direction(self):
        return self.__direction
    @direction.setter
    def direction(self, value = [1, 0, 0]):
        self.__direction = [value]
    def setDirection(self, direction = [1, 0, 0]):
        self.__direction = [direction]
        return self
    def addDirection(self, direction = [1, 0, 0]):
        if self.__direction == None:            self.__direction =  []
        self.__direction +=  [direction]
        return self
    def removeDirection(self, direction):
        self.__direction = [x for x in self.__direction if x not in direction]
        return self.__direction
    def getDirection(self, direction = [1, 0, 0]):
        return self.__direction
    def direction_changed(self, direction = [1, 0, 0]):
        return self.__direction
    @property
    def enabled(self):
        return self.__enabled
    @enabled.setter
    def enabled(self, value = True):
        self.__enabled = [value]
    def setEnabled(self, enabled = True):
        self.__enabled = [enabled]
        return self
    def addEnabled(self, enabled = True):
        if self.__enabled == None:            self.__enabled =  []
        self.__enabled +=  [enabled]
        return self
    def removeEnabled(self, enabled):
        self.__enabled = [x for x in self.__enabled if x not in enabled]
        return self.__enabled
    def isEnabled(self, enabled = True):
        return self.__enabled
    @property
    def gustiness(self):
        return self.__gustiness
    @gustiness.setter
    def gustiness(self, value = 0.1):
        if value == None or value  <  0:
            return None
        self.__gustiness = [value]
    def setGustiness(self, gustiness = 0.1):
        if gustiness == None or gustiness  <  0:
            return None
        self.__gustiness = [gustiness]
        return self
    def addGustiness(self, gustiness = 0.1):
        if gustiness == None or gustiness  <  0:
            return None
        if self.__gustiness == None:            self.__gustiness =  []
        self.__gustiness +=  [gustiness]
        return self
    def removeGustiness(self, gustiness):
        self.__gustiness = [x for x in self.__gustiness if x not in gustiness]
        return self.__gustiness
    def getGustiness(self, gustiness = 0.1):
        return self.__gustiness
    def gustiness_changed(self, gustiness = 0.1):
        return self.__gustiness
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def speed(self):
        return self.__speed
    @speed.setter
    def speed(self, value = 0.1):
        if value == None or value  <  0:
            return None
        self.__speed = [value]
    def setSpeed(self, speed = 0.1):
        if speed == None or speed  <  0:
            return None
        self.__speed = [speed]
        return self
    def addSpeed(self, speed = 0.1):
        if speed == None or speed  <  0:
            return None
        if self.__speed == None:            self.__speed =  []
        self.__speed +=  [speed]
        return self
    def removeSpeed(self, speed):
        self.__speed = [x for x in self.__speed if x not in speed]
        return self.__speed
    def getSpeed(self, speed = 0.1):
        return self.__speed
    def speed_changed(self, speed = 0.1):
        return self.__speed
    @property
    def turbulence(self):
        return self.__turbulence
    @turbulence.setter
    def turbulence(self, value = 0):
        if value == None or value  <  0:
            return None
        if value == None or value  >  1:
            return None
        self.__turbulence = [value]
    def setTurbulence(self, turbulence = 0):
        if turbulence == None or turbulence  <  0:
            return None
        if turbulence == None or turbulence  >  1:
            return None
        self.__turbulence = [turbulence]
        return self
    def addTurbulence(self, turbulence = 0):
        if turbulence == None or turbulence  <  0:
            return None
        if turbulence == None or turbulence  >  1:
            return None
        if self.__turbulence == None:            self.__turbulence =  []
        self.__turbulence +=  [turbulence]
        return self
    def removeTurbulence(self, turbulence):
        self.__turbulence = [x for x in self.__turbulence if x not in turbulence]
        return self.__turbulence
    def getTurbulence(self, turbulence = 0):
        return self.__turbulence
    def turbulence_changed(self, turbulence = 0):
        return self.__turbulence
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<WindPhysicsModel'
        if self.__direction is not None:
            if isinstance(self.__direction, six.string_types):
                str += ' direction="'+self.__direction+'"'
            else:
                str += ' direction="'+self.__direction[0]+'"'
        if self.__enabled is not None:
            if isinstance(self.__enabled, six.string_types):
                str += ' enabled="'+self.__enabled+'"'
            else:
                str += ' enabled="'+self.__enabled[0]+'"'
        if self.__gustiness is not None:
            if isinstance(self.__gustiness, six.string_types):
                str += ' gustiness="'+self.__gustiness+'"'
            else:
                str += ' gustiness="'+self.__gustiness[0]+'"'
        if self.__speed is not None:
            if isinstance(self.__speed, six.string_types):
                str += ' speed="'+self.__speed+'"'
            else:
                str += ' speed="'+self.__speed[0]+'"'
        if self.__turbulence is not None:
            if isinstance(self.__turbulence, six.string_types):
                str += ' turbulence="'+self.__turbulence+'"'
            else:
                str += ' turbulence="'+self.__turbulence[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</WindPhysicsModel>'
        return str


class WorldInfo(X3DInfoNode):
    def __init__(self, **kwargs):
        super(WorldInfo, self).__init__(**kwargs)
        info  = kwargs.pop("info", None)
        self.__info = info
        metadata  = kwargs.pop("metadata", None)
        self.__metadata = metadata
        title  = kwargs.pop("title", None)
        self.__title = title
        DEF  = kwargs.pop("DEF", None)
        self.__DEF = DEF
        USE  = kwargs.pop("USE", None)
        self.__USE = USE
        class_  = kwargs.pop("class_", None)
        self.__class_ = class_
    @property
    def info(self):
        return self.__info
    @info.setter
    def info(self, value = None):
        self.__info = [value]
    def setInfo(self, info = None):
        self.__info = [info]
        return self
    def addInfo(self, info = None):
        if self.__info == None:            self.__info =  []
        self.__info +=  [info]
        return self
    def removeInfo(self, info):
        self.__info = [x for x in self.__info if x not in info]
        return self.__info
    def getInfo(self, info = None):
        return self.__info
    def info_changed(self, info = None):
        return self.__info
    @property
    def metadata(self):
        return self.__metadata
    @metadata.setter
    def metadata(self, value = None):
        self.__metadata = [value]
    def setMetadata(self, metadata = None):
        self.__metadata = [metadata]
        return self
    def addMetadata(self, metadata = None):
        if self.__metadata == None:            self.__metadata =  []
        self.__metadata +=  [metadata]
        return self
    def removeMetadata(self, metadata):
        self.__metadata = [x for x in self.__metadata if x not in metadata]
        return self.__metadata
    def getMetadata(self, metadata = None):
        return self.__metadata
    def metadata_changed(self, metadata = None):
        return self.__metadata
    @property
    def title(self):
        return self.__title
    @title.setter
    def title(self, value = None):
        self.__title = [value]
    def setTitle(self, title = None):
        self.__title = [title]
        return self
    def addTitle(self, title = None):
        if self.__title == None:            self.__title =  []
        self.__title +=  [title]
        return self
    def removeTitle(self, title):
        self.__title = [x for x in self.__title if x not in title]
        return self.__title
    def getTitle(self, title = None):
        return self.__title
    def title_changed(self, title = None):
        return self.__title
    @property
    def DEF(self):
        return self.__DEF
    @DEF.setter
    def DEF(self, value = None):
        self.__DEF = [value]
    def setDEF(self, DEF = None):
        self.__DEF = [DEF]
        return self
    def addDEF(self, DEF = None):
        if self.__DEF == None:            self.__DEF =  []
        self.__DEF +=  [DEF]
        return self
    def removeDEF(self, DEF):
        self.__DEF = [x for x in self.__DEF if x not in DEF]
        return self.__DEF
    def getDEF(self, DEF = None):
        return self.__DEF
    def DEF_changed(self, DEF = None):
        return self.__DEF
    @property
    def USE(self):
        return self.__USE
    @USE.setter
    def USE(self, value = None):
        self.__USE = [value]
    def setUSE(self, USE = None):
        self.__USE = [USE]
        return self
    def addUSE(self, USE = None):
        if self.__USE == None:            self.__USE =  []
        self.__USE +=  [USE]
        return self
    def removeUSE(self, USE):
        self.__USE = [x for x in self.__USE if x not in USE]
        return self.__USE
    def getUSE(self, USE = None):
        return self.__USE
    def USE_changed(self, USE = None):
        return self.__USE
    @property
    def class_(self):
        return self.__class_
    @class_.setter
    def class_(self, value = None):
        self.__class_ = [value]
    def setClass(self, class_ = None):
        self.__class_ = [class_]
        return self
    def addClass(self, class_ = None):
        if self.__class_ == None:            self.__class_ =  []
        self.__class_ +=  [class_]
        return self
    def removeClass(self, class_):
        self.__class_ = [x for x in self.__class_ if x not in class_]
        return self.__class_
    def getClass(self, class_ = None):
        return self.__class_
    def class_changed(self, class_ = None):
        return self.__class_
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<WorldInfo'
        if self.__info is not None:
            if isinstance(self.__info, six.string_types):
                str += ' info="'+self.__info+'"'
            else:
                str += ' info="'+self.__info[0]+'"'
        if self.__title is not None:
            if isinstance(self.__title, six.string_types):
                str += ' title="'+self.__title+'"'
            else:
                str += ' title="'+self.__title[0]+'"'
        if self.__DEF is not None:
            if isinstance(self.__DEF, six.string_types):
                str += ' DEF="'+self.__DEF+'"'
            else:
                str += ' DEF="'+self.__DEF[0]+'"'
        if self.__USE is not None:
            if isinstance(self.__USE, six.string_types):
                str += ' USE="'+self.__USE+'"'
            else:
                str += ' USE="'+self.__USE[0]+'"'
        if self.__class_ is not None:
            if isinstance(self.__class_, six.string_types):
                str += ' class_="'+self.__class_+'"'
            else:
                str += ' class_="'+self.__class_[0]+'"'
        str += '>'
        str += '<metadata'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__metadata is not None:
           for s in self.__metadata:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</metadata>'
        str += '</WorldInfo>'
        return str


class component(object):
    def __init__(self, **kwargs):
        super(component, self).__init__()
        level  = kwargs.pop("level", 1)
        if level == None or level  <  1:
            return None
        if level == None or level  >  5:
            return None
        self.__level = level
        name  = kwargs.pop("name", None)
        if 'Core' == name:
            pass
        elif 'CADGeometry' == name:
            pass
        elif 'CubeMapTexturing' == name:
            pass
        elif 'DIS' == name:
            pass
        elif 'EnvironmentalEffects' == name:
            pass
        elif 'EnvironmentalSensor' == name:
            pass
        elif 'EventUtilities' == name:
            pass
        elif 'Followers' == name:
            pass
        elif 'Geometry2D' == name:
            pass
        elif 'Geometry3D' == name:
            pass
        elif 'Geospatial' == name:
            pass
        elif 'Grouping' == name:
            pass
        elif 'H-Anim' == name:
            pass
        elif 'Interpolation' == name:
            pass
        elif 'KeyDeviceSensor' == name:
            pass
        elif 'Layering' == name:
            pass
        elif 'Layout' == name:
            pass
        elif 'Lighting' == name:
            pass
        elif 'Navigation' == name:
            pass
        elif 'Networking' == name:
            pass
        elif 'NURBS' == name:
            pass
        elif 'ParticleSystems' == name:
            pass
        elif 'Picking' == name:
            pass
        elif 'PointingDeviceSensor' == name:
            pass
        elif 'Rendering' == name:
            pass
        elif 'RigidBodyPhysics' == name:
            pass
        elif 'Scripting' == name:
            pass
        elif 'Shaders' == name:
            pass
        elif 'Shape' == name:
            pass
        elif 'Sound' == name:
            pass
        elif 'Text' == name:
            pass
        elif 'Texturing' == name:
            pass
        elif 'Texturing3D' == name:
            pass
        elif 'Time' == name:
            pass
        elif 'VolumeRendering' == name:
            pass
        else:
            return None
        self.__name = name
    @property
    def level(self):
        return self.__level
    @level.setter
    def level(self, value = 1):
        if value == None or value  <  1:
            return None
        if value == None or value  >  5:
            return None
        self.__level = [value]
    def setLevel(self, level = 1):
        if level == None or level  <  1:
            return None
        if level == None or level  >  5:
            return None
        self.__level = [level]
        return self
    def addLevel(self, level = 1):
        if level == None or level  <  1:
            return None
        if level == None or level  >  5:
            return None
        if self.__level == None:            self.__level =  []
        self.__level +=  [level]
        return self
    def removeLevel(self, level):
        self.__level = [x for x in self.__level if x not in level]
        return self.__level
    def getLevel(self, level = 1):
        return self.__level
    def level_changed(self, level = 1):
        return self.__level
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        if 'Core' == value:
            pass
        elif 'CADGeometry' == value:
            pass
        elif 'CubeMapTexturing' == value:
            pass
        elif 'DIS' == value:
            pass
        elif 'EnvironmentalEffects' == value:
            pass
        elif 'EnvironmentalSensor' == value:
            pass
        elif 'EventUtilities' == value:
            pass
        elif 'Followers' == value:
            pass
        elif 'Geometry2D' == value:
            pass
        elif 'Geometry3D' == value:
            pass
        elif 'Geospatial' == value:
            pass
        elif 'Grouping' == value:
            pass
        elif 'H-Anim' == value:
            pass
        elif 'Interpolation' == value:
            pass
        elif 'KeyDeviceSensor' == value:
            pass
        elif 'Layering' == value:
            pass
        elif 'Layout' == value:
            pass
        elif 'Lighting' == value:
            pass
        elif 'Navigation' == value:
            pass
        elif 'Networking' == value:
            pass
        elif 'NURBS' == value:
            pass
        elif 'ParticleSystems' == value:
            pass
        elif 'Picking' == value:
            pass
        elif 'PointingDeviceSensor' == value:
            pass
        elif 'Rendering' == value:
            pass
        elif 'RigidBodyPhysics' == value:
            pass
        elif 'Scripting' == value:
            pass
        elif 'Shaders' == value:
            pass
        elif 'Shape' == value:
            pass
        elif 'Sound' == value:
            pass
        elif 'Text' == value:
            pass
        elif 'Texturing' == value:
            pass
        elif 'Texturing3D' == value:
            pass
        elif 'Time' == value:
            pass
        elif 'VolumeRendering' == value:
            pass
        else:
            return None
        self.__name = [value]
    def setName(self, name = None):
        if 'Core' == name:
            pass
        elif 'CADGeometry' == name:
            pass
        elif 'CubeMapTexturing' == name:
            pass
        elif 'DIS' == name:
            pass
        elif 'EnvironmentalEffects' == name:
            pass
        elif 'EnvironmentalSensor' == name:
            pass
        elif 'EventUtilities' == name:
            pass
        elif 'Followers' == name:
            pass
        elif 'Geometry2D' == name:
            pass
        elif 'Geometry3D' == name:
            pass
        elif 'Geospatial' == name:
            pass
        elif 'Grouping' == name:
            pass
        elif 'H-Anim' == name:
            pass
        elif 'Interpolation' == name:
            pass
        elif 'KeyDeviceSensor' == name:
            pass
        elif 'Layering' == name:
            pass
        elif 'Layout' == name:
            pass
        elif 'Lighting' == name:
            pass
        elif 'Navigation' == name:
            pass
        elif 'Networking' == name:
            pass
        elif 'NURBS' == name:
            pass
        elif 'ParticleSystems' == name:
            pass
        elif 'Picking' == name:
            pass
        elif 'PointingDeviceSensor' == name:
            pass
        elif 'Rendering' == name:
            pass
        elif 'RigidBodyPhysics' == name:
            pass
        elif 'Scripting' == name:
            pass
        elif 'Shaders' == name:
            pass
        elif 'Shape' == name:
            pass
        elif 'Sound' == name:
            pass
        elif 'Text' == name:
            pass
        elif 'Texturing' == name:
            pass
        elif 'Texturing3D' == name:
            pass
        elif 'Time' == name:
            pass
        elif 'VolumeRendering' == name:
            pass
        else:
            return None
        self.__name = [name]
        return self
    def addName(self, name = None):
        if 'Core' == name:
            pass
        elif 'CADGeometry' == name:
            pass
        elif 'CubeMapTexturing' == name:
            pass
        elif 'DIS' == name:
            pass
        elif 'EnvironmentalEffects' == name:
            pass
        elif 'EnvironmentalSensor' == name:
            pass
        elif 'EventUtilities' == name:
            pass
        elif 'Followers' == name:
            pass
        elif 'Geometry2D' == name:
            pass
        elif 'Geometry3D' == name:
            pass
        elif 'Geospatial' == name:
            pass
        elif 'Grouping' == name:
            pass
        elif 'H-Anim' == name:
            pass
        elif 'Interpolation' == name:
            pass
        elif 'KeyDeviceSensor' == name:
            pass
        elif 'Layering' == name:
            pass
        elif 'Layout' == name:
            pass
        elif 'Lighting' == name:
            pass
        elif 'Navigation' == name:
            pass
        elif 'Networking' == name:
            pass
        elif 'NURBS' == name:
            pass
        elif 'ParticleSystems' == name:
            pass
        elif 'Picking' == name:
            pass
        elif 'PointingDeviceSensor' == name:
            pass
        elif 'Rendering' == name:
            pass
        elif 'RigidBodyPhysics' == name:
            pass
        elif 'Scripting' == name:
            pass
        elif 'Shaders' == name:
            pass
        elif 'Shape' == name:
            pass
        elif 'Sound' == name:
            pass
        elif 'Text' == name:
            pass
        elif 'Texturing' == name:
            pass
        elif 'Texturing3D' == name:
            pass
        elif 'Time' == name:
            pass
        elif 'VolumeRendering' == name:
            pass
        else:
            return None
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<component'
        if self.__level is not None:
            if isinstance(self.__level, six.string_types):
                str += ' level="'+self.__level+'"'
            else:
                str += ' level="'+self.__level[0]+'"'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        str += '>'
        str += '</component>'
        return str


class connect(object):
    def __init__(self, **kwargs):
        super(connect, self).__init__()
        nodeField  = kwargs.pop("nodeField", None)
        self.__nodeField = nodeField
        protoField  = kwargs.pop("protoField", None)
        self.__protoField = protoField
    @property
    def nodeField(self):
        return self.__nodeField
    @nodeField.setter
    def nodeField(self, value = None):
        self.__nodeField = [value]
    def setNodeField(self, nodeField = None):
        self.__nodeField = [nodeField]
        return self
    def addNodeField(self, nodeField = None):
        if self.__nodeField == None:            self.__nodeField =  []
        self.__nodeField +=  [nodeField]
        return self
    def removeNodeField(self, nodeField):
        self.__nodeField = [x for x in self.__nodeField if x not in nodeField]
        return self.__nodeField
    def getNodeField(self, nodeField = None):
        return self.__nodeField
    def nodeField_changed(self, nodeField = None):
        return self.__nodeField
    @property
    def protoField(self):
        return self.__protoField
    @protoField.setter
    def protoField(self, value = None):
        self.__protoField = [value]
    def setProtoField(self, protoField = None):
        self.__protoField = [protoField]
        return self
    def addProtoField(self, protoField = None):
        if self.__protoField == None:            self.__protoField =  []
        self.__protoField +=  [protoField]
        return self
    def removeProtoField(self, protoField):
        self.__protoField = [x for x in self.__protoField if x not in protoField]
        return self.__protoField
    def getProtoField(self, protoField = None):
        return self.__protoField
    def protoField_changed(self, protoField = None):
        return self.__protoField
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<connect'
        if self.__nodeField is not None:
            if isinstance(self.__nodeField, six.string_types):
                str += ' nodeField="'+self.__nodeField+'"'
            else:
                str += ' nodeField="'+self.__nodeField[0]+'"'
        if self.__protoField is not None:
            if isinstance(self.__protoField, six.string_types):
                str += ' protoField="'+self.__protoField+'"'
            else:
                str += ' protoField="'+self.__protoField[0]+'"'
        str += '>'
        str += '</connect>'
        return str


class EXPORT(object):
    def __init__(self, **kwargs):
        super(EXPORT, self).__init__()
        AS  = kwargs.pop("AS", None)
        self.__AS = AS
        localDEF  = kwargs.pop("localDEF", None)
        self.__localDEF = localDEF
    @property
    def AS(self):
        return self.__AS
    @AS.setter
    def AS(self, value = None):
        self.__AS = [value]
    def setAS(self, AS = None):
        self.__AS = [AS]
        return self
    def addAS(self, AS = None):
        if self.__AS == None:            self.__AS =  []
        self.__AS +=  [AS]
        return self
    def removeAS(self, AS):
        self.__AS = [x for x in self.__AS if x not in AS]
        return self.__AS
    def getAS(self, AS = None):
        return self.__AS
    def AS_changed(self, AS = None):
        return self.__AS
    @property
    def localDEF(self):
        return self.__localDEF
    @localDEF.setter
    def localDEF(self, value = None):
        self.__localDEF = [value]
    def setLocalDEF(self, localDEF = None):
        self.__localDEF = [localDEF]
        return self
    def addLocalDEF(self, localDEF = None):
        if self.__localDEF == None:            self.__localDEF =  []
        self.__localDEF +=  [localDEF]
        return self
    def removeLocalDEF(self, localDEF):
        self.__localDEF = [x for x in self.__localDEF if x not in localDEF]
        return self.__localDEF
    def getLocalDEF(self, localDEF = None):
        return self.__localDEF
    def localDEF_changed(self, localDEF = None):
        return self.__localDEF
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<EXPORT'
        if self.__AS is not None:
            if isinstance(self.__AS, six.string_types):
                str += ' AS="'+self.__AS+'"'
            else:
                str += ' AS="'+self.__AS[0]+'"'
        if self.__localDEF is not None:
            if isinstance(self.__localDEF, six.string_types):
                str += ' localDEF="'+self.__localDEF+'"'
            else:
                str += ' localDEF="'+self.__localDEF[0]+'"'
        str += '>'
        str += '</EXPORT>'
        return str


class ExternProtoDeclare(object):
    def __init__(self, **kwargs):
        super(ExternProtoDeclare, self).__init__()
        appinfo  = kwargs.pop("appinfo", None)
        self.__appinfo = appinfo
        documentation  = kwargs.pop("documentation", None)
        self.__documentation = documentation
        field  = kwargs.pop("field", None)
        self.__field = field
        name  = kwargs.pop("name", None)
        self.__name = name
        url  = kwargs.pop("url", None)
        self.__url = url
    @property
    def appinfo(self):
        return self.__appinfo
    @appinfo.setter
    def appinfo(self, value = None):
        self.__appinfo = [value]
    def setAppinfo(self, appinfo = None):
        self.__appinfo = [appinfo]
        return self
    def addAppinfo(self, appinfo = None):
        if self.__appinfo == None:            self.__appinfo =  []
        self.__appinfo +=  [appinfo]
        return self
    def removeAppinfo(self, appinfo):
        self.__appinfo = [x for x in self.__appinfo if x not in appinfo]
        return self.__appinfo
    def getAppinfo(self, appinfo = None):
        return self.__appinfo
    def appinfo_changed(self, appinfo = None):
        return self.__appinfo
    @property
    def documentation(self):
        return self.__documentation
    @documentation.setter
    def documentation(self, value = None):
        self.__documentation = [value]
    def setDocumentation(self, documentation = None):
        self.__documentation = [documentation]
        return self
    def addDocumentation(self, documentation = None):
        if self.__documentation == None:            self.__documentation =  []
        self.__documentation +=  [documentation]
        return self
    def removeDocumentation(self, documentation):
        self.__documentation = [x for x in self.__documentation if x not in documentation]
        return self.__documentation
    def getDocumentation(self, documentation = None):
        return self.__documentation
    def documentation_changed(self, documentation = None):
        return self.__documentation
    @property
    def field(self):
        return self.__field
    @field.setter
    def field(self, value = None):
        self.__field = [value]
    def setField(self, field = None):
        self.__field = [field]
        return self
    def addField(self, field = None):
        if self.__field == None:            self.__field =  []
        self.__field +=  [field]
        return self
    def removeField(self, field):
        self.__field = [x for x in self.__field if x not in field]
        return self.__field
    def getField(self, field = None):
        return self.__field
    def field_changed(self, field = None):
        return self.__field
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        self.__name = [value]
    def setName(self, name = None):
        self.__name = [name]
        return self
    def addName(self, name = None):
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def url(self):
        return self.__url
    @url.setter
    def url(self, value = None):
        self.__url = [value]
    def setUrl(self, url = None):
        self.__url = [url]
        return self
    def addUrl(self, url = None):
        if self.__url == None:            self.__url =  []
        self.__url +=  [url]
        return self
    def removeUrl(self, url):
        self.__url = [x for x in self.__url if x not in url]
        return self.__url
    def getUrl(self, url = None):
        return self.__url
    def url_changed(self, url = None):
        return self.__url
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ExternProtoDeclare'
        if self.__appinfo is not None:
            if isinstance(self.__appinfo, six.string_types):
                str += ' appinfo="'+self.__appinfo+'"'
            else:
                str += ' appinfo="'+self.__appinfo[0]+'"'
        if self.__documentation is not None:
            if isinstance(self.__documentation, six.string_types):
                str += ' documentation="'+self.__documentation+'"'
            else:
                str += ' documentation="'+self.__documentation[0]+'"'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        if self.__url is not None:
            if isinstance(self.__url, six.string_types):
                str += ' url="'+self.__url+'"'
            else:
                str += ' url="'+self.__url[0]+'"'
        str += '>'
        str += '<field'
        if self.__field is not None:
           for s in self.__field:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__field is not None:
           for s in self.__field:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</field>'
        str += '</ExternProtoDeclare>'
        return str


class field(object):
    def __init__(self, **kwargs):
        super(field, self).__init__()
        accessType  = kwargs.pop("accessType", None)
        self.__accessType = accessType
        appinfo  = kwargs.pop("appinfo", None)
        self.__appinfo = appinfo
        children  = kwargs.pop("children", None)
        self.__children = children
        documentation  = kwargs.pop("documentation", None)
        self.__documentation = documentation
        name  = kwargs.pop("name", None)
        self.__name = name
        type  = kwargs.pop("type", None)
        if 'SFBool' == type:
            pass
        elif 'MFBool' == type:
            pass
        elif 'SFColor' == type:
            pass
        elif 'MFColor' == type:
            pass
        elif 'SFColorRGBA' == type:
            pass
        elif 'MFColorRGBA' == type:
            pass
        elif 'SFDouble' == type:
            pass
        elif 'MFDouble' == type:
            pass
        elif 'SFFloat' == type:
            pass
        elif 'MFFloat' == type:
            pass
        elif 'SFImage' == type:
            pass
        elif 'MFImage' == type:
            pass
        elif 'SFInt32' == type:
            pass
        elif 'SFNode' == type:
            pass
        elif 'MFNode' == type:
            pass
        elif 'MFInt32' == type:
            pass
        elif 'SFRotation' == type:
            pass
        elif 'MFRotation' == type:
            pass
        elif 'SFString' == type:
            pass
        elif 'MFString' == type:
            pass
        elif 'SFTime' == type:
            pass
        elif 'MFTime' == type:
            pass
        elif 'SFVec2d' == type:
            pass
        elif 'MFVec2d' == type:
            pass
        elif 'SFVec2f' == type:
            pass
        elif 'MFVec2f' == type:
            pass
        elif 'SFVec3d' == type:
            pass
        elif 'MFVec3d' == type:
            pass
        elif 'SFVec3f' == type:
            pass
        elif 'MFVec3f' == type:
            pass
        elif 'SFVec4d' == type:
            pass
        elif 'MFVec4d' == type:
            pass
        elif 'SFVec4f' == type:
            pass
        elif 'MFVec4f' == type:
            pass
        elif 'SFMatrix3d' == type:
            pass
        elif 'MFMatrix3d' == type:
            pass
        elif 'SFMatrix3f' == type:
            pass
        elif 'MFMatrix3f' == type:
            pass
        elif 'SFMatrix4d' == type:
            pass
        elif 'MFMatrix4d' == type:
            pass
        elif 'SFMatrix4f' == type:
            pass
        elif 'MFMatrix4f' == type:
            pass
        else:
            return None
        self.__type = type
        value  = kwargs.pop("value", None)
        self.__value = value
        children  = kwargs.pop("children", None)
        self.__children = children
    @property
    def accessType(self):
        return self.__accessType
    @accessType.setter
    def accessType(self, value = None):
        if 'initializeOnly' == value:
            pass
        elif 'inputOnly' == value:
            pass
        elif 'outputOnly' == value:
            pass
        elif 'inputOutput' == value:
            pass
        else:
            return None
        self.__accessType = [value]
    def setAccessType(self, accessType = None):
        if 'initializeOnly' == accessType:
            pass
        elif 'inputOnly' == accessType:
            pass
        elif 'outputOnly' == accessType:
            pass
        elif 'inputOutput' == accessType:
            pass
        else:
            return None
        self.__accessType = [accessType]
        return self
    def addAccessType(self, accessType = None):
        if 'initializeOnly' == accessType:
            pass
        elif 'inputOnly' == accessType:
            pass
        elif 'outputOnly' == accessType:
            pass
        elif 'inputOutput' == accessType:
            pass
        else:
            return None
        if self.__accessType == None:            self.__accessType =  []
        self.__accessType +=  [accessType]
        return self
    def removeAccessType(self, accessType):
        self.__accessType = [x for x in self.__accessType if x not in accessType]
        return self.__accessType
    def getAccessType(self, accessType = None):
        return self.__accessType
    def accessType_changed(self, accessType = None):
        return self.__accessType
    @property
    def appinfo(self):
        return self.__appinfo
    @appinfo.setter
    def appinfo(self, value = None):
        self.__appinfo = [value]
    def setAppinfo(self, appinfo = None):
        self.__appinfo = [appinfo]
        return self
    def addAppinfo(self, appinfo = None):
        if self.__appinfo == None:            self.__appinfo =  []
        self.__appinfo +=  [appinfo]
        return self
    def removeAppinfo(self, appinfo):
        self.__appinfo = [x for x in self.__appinfo if x not in appinfo]
        return self.__appinfo
    def getAppinfo(self, appinfo = None):
        return self.__appinfo
    def appinfo_changed(self, appinfo = None):
        return self.__appinfo
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    @property
    def documentation(self):
        return self.__documentation
    @documentation.setter
    def documentation(self, value = None):
        self.__documentation = [value]
    def setDocumentation(self, documentation = None):
        self.__documentation = [documentation]
        return self
    def addDocumentation(self, documentation = None):
        if self.__documentation == None:            self.__documentation =  []
        self.__documentation +=  [documentation]
        return self
    def removeDocumentation(self, documentation):
        self.__documentation = [x for x in self.__documentation if x not in documentation]
        return self.__documentation
    def getDocumentation(self, documentation = None):
        return self.__documentation
    def documentation_changed(self, documentation = None):
        return self.__documentation
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        self.__name = [value]
    def setName(self, name = None):
        self.__name = [name]
        return self
    def addName(self, name = None):
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def type(self):
        return self.__type
    @type.setter
    def type(self, value = None):
        if 'SFBool' == value:
            pass
        elif 'MFBool' == value:
            pass
        elif 'SFColor' == value:
            pass
        elif 'MFColor' == value:
            pass
        elif 'SFColorRGBA' == value:
            pass
        elif 'MFColorRGBA' == value:
            pass
        elif 'SFDouble' == value:
            pass
        elif 'MFDouble' == value:
            pass
        elif 'SFFloat' == value:
            pass
        elif 'MFFloat' == value:
            pass
        elif 'SFImage' == value:
            pass
        elif 'MFImage' == value:
            pass
        elif 'SFInt32' == value:
            pass
        elif 'SFNode' == value:
            pass
        elif 'MFNode' == value:
            pass
        elif 'MFInt32' == value:
            pass
        elif 'SFRotation' == value:
            pass
        elif 'MFRotation' == value:
            pass
        elif 'SFString' == value:
            pass
        elif 'MFString' == value:
            pass
        elif 'SFTime' == value:
            pass
        elif 'MFTime' == value:
            pass
        elif 'SFVec2d' == value:
            pass
        elif 'MFVec2d' == value:
            pass
        elif 'SFVec2f' == value:
            pass
        elif 'MFVec2f' == value:
            pass
        elif 'SFVec3d' == value:
            pass
        elif 'MFVec3d' == value:
            pass
        elif 'SFVec3f' == value:
            pass
        elif 'MFVec3f' == value:
            pass
        elif 'SFVec4d' == value:
            pass
        elif 'MFVec4d' == value:
            pass
        elif 'SFVec4f' == value:
            pass
        elif 'MFVec4f' == value:
            pass
        elif 'SFMatrix3d' == value:
            pass
        elif 'MFMatrix3d' == value:
            pass
        elif 'SFMatrix3f' == value:
            pass
        elif 'MFMatrix3f' == value:
            pass
        elif 'SFMatrix4d' == value:
            pass
        elif 'MFMatrix4d' == value:
            pass
        elif 'SFMatrix4f' == value:
            pass
        elif 'MFMatrix4f' == value:
            pass
        else:
            return None
        self.__type = [value]
    def setType(self, type = None):
        if 'SFBool' == type:
            pass
        elif 'MFBool' == type:
            pass
        elif 'SFColor' == type:
            pass
        elif 'MFColor' == type:
            pass
        elif 'SFColorRGBA' == type:
            pass
        elif 'MFColorRGBA' == type:
            pass
        elif 'SFDouble' == type:
            pass
        elif 'MFDouble' == type:
            pass
        elif 'SFFloat' == type:
            pass
        elif 'MFFloat' == type:
            pass
        elif 'SFImage' == type:
            pass
        elif 'MFImage' == type:
            pass
        elif 'SFInt32' == type:
            pass
        elif 'SFNode' == type:
            pass
        elif 'MFNode' == type:
            pass
        elif 'MFInt32' == type:
            pass
        elif 'SFRotation' == type:
            pass
        elif 'MFRotation' == type:
            pass
        elif 'SFString' == type:
            pass
        elif 'MFString' == type:
            pass
        elif 'SFTime' == type:
            pass
        elif 'MFTime' == type:
            pass
        elif 'SFVec2d' == type:
            pass
        elif 'MFVec2d' == type:
            pass
        elif 'SFVec2f' == type:
            pass
        elif 'MFVec2f' == type:
            pass
        elif 'SFVec3d' == type:
            pass
        elif 'MFVec3d' == type:
            pass
        elif 'SFVec3f' == type:
            pass
        elif 'MFVec3f' == type:
            pass
        elif 'SFVec4d' == type:
            pass
        elif 'MFVec4d' == type:
            pass
        elif 'SFVec4f' == type:
            pass
        elif 'MFVec4f' == type:
            pass
        elif 'SFMatrix3d' == type:
            pass
        elif 'MFMatrix3d' == type:
            pass
        elif 'SFMatrix3f' == type:
            pass
        elif 'MFMatrix3f' == type:
            pass
        elif 'SFMatrix4d' == type:
            pass
        elif 'MFMatrix4d' == type:
            pass
        elif 'SFMatrix4f' == type:
            pass
        elif 'MFMatrix4f' == type:
            pass
        else:
            return None
        self.__type = [type]
        return self
    def addType(self, type = None):
        if 'SFBool' == type:
            pass
        elif 'MFBool' == type:
            pass
        elif 'SFColor' == type:
            pass
        elif 'MFColor' == type:
            pass
        elif 'SFColorRGBA' == type:
            pass
        elif 'MFColorRGBA' == type:
            pass
        elif 'SFDouble' == type:
            pass
        elif 'MFDouble' == type:
            pass
        elif 'SFFloat' == type:
            pass
        elif 'MFFloat' == type:
            pass
        elif 'SFImage' == type:
            pass
        elif 'MFImage' == type:
            pass
        elif 'SFInt32' == type:
            pass
        elif 'SFNode' == type:
            pass
        elif 'MFNode' == type:
            pass
        elif 'MFInt32' == type:
            pass
        elif 'SFRotation' == type:
            pass
        elif 'MFRotation' == type:
            pass
        elif 'SFString' == type:
            pass
        elif 'MFString' == type:
            pass
        elif 'SFTime' == type:
            pass
        elif 'MFTime' == type:
            pass
        elif 'SFVec2d' == type:
            pass
        elif 'MFVec2d' == type:
            pass
        elif 'SFVec2f' == type:
            pass
        elif 'MFVec2f' == type:
            pass
        elif 'SFVec3d' == type:
            pass
        elif 'MFVec3d' == type:
            pass
        elif 'SFVec3f' == type:
            pass
        elif 'MFVec3f' == type:
            pass
        elif 'SFVec4d' == type:
            pass
        elif 'MFVec4d' == type:
            pass
        elif 'SFVec4f' == type:
            pass
        elif 'MFVec4f' == type:
            pass
        elif 'SFMatrix3d' == type:
            pass
        elif 'MFMatrix3d' == type:
            pass
        elif 'SFMatrix3f' == type:
            pass
        elif 'MFMatrix3f' == type:
            pass
        elif 'SFMatrix4d' == type:
            pass
        elif 'MFMatrix4d' == type:
            pass
        elif 'SFMatrix4f' == type:
            pass
        elif 'MFMatrix4f' == type:
            pass
        else:
            return None
        if self.__type == None:            self.__type =  []
        self.__type +=  [type]
        return self
    def removeType(self, type):
        self.__type = [x for x in self.__type if x not in type]
        return self.__type
    def getType(self, type = None):
        return self.__type
    def type_changed(self, type = None):
        return self.__type
    @property
    def value(self):
        return self.__value
    @value.setter
    def value(self, value = None):
        self.__value = [value]
    def setValue(self, value = None):
        self.__value = [value]
        return self
    def addValue(self, value = None):
        if self.__value == None:            self.__value =  []
        self.__value +=  [value]
        return self
    def removeValue(self, value):
        self.__value = [x for x in self.__value if x not in value]
        return self.__value
    def getValue(self, value = None):
        return self.__value
    def value_changed(self, value = None):
        return self.__value
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    def toXML(self):
        str = ''
        str += '<field'
        if self.__accessType is not None:
            if isinstance(self.__accessType, six.string_types):
                str += ' accessType="'+self.__accessType+'"'
            else:
                str += ' accessType="'+self.__accessType[0]+'"'
        if self.__appinfo is not None:
            if isinstance(self.__appinfo, six.string_types):
                str += ' appinfo="'+self.__appinfo+'"'
            else:
                str += ' appinfo="'+self.__appinfo[0]+'"'
        if self.__documentation is not None:
            if isinstance(self.__documentation, six.string_types):
                str += ' documentation="'+self.__documentation+'"'
            else:
                str += ' documentation="'+self.__documentation[0]+'"'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        if self.__type is not None:
            if isinstance(self.__type, six.string_types):
                str += ' type="'+self.__type+'"'
            else:
                str += ' type="'+self.__type[0]+'"'
        if self.__value is not None:
            if isinstance(self.__value, six.string_types):
                str += ' value="'+self.__value+'"'
            else:
                str += ' value="'+self.__value[0]+'"'
        str += '>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '</field>'
        return str


class fieldValue(object):
    def __init__(self, **kwargs):
        super(fieldValue, self).__init__()
        children  = kwargs.pop("children", None)
        self.__children = children
        name  = kwargs.pop("name", None)
        self.__name = name
        value  = kwargs.pop("value", None)
        self.__value = value
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        self.__name = [value]
    def setName(self, name = None):
        self.__name = [name]
        return self
    def addName(self, name = None):
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def value(self):
        return self.__value
    @value.setter
    def value(self, value = None):
        self.__value = [value]
    def setValue(self, value = None):
        self.__value = [value]
        return self
    def addValue(self, value = None):
        if self.__value == None:            self.__value =  []
        self.__value +=  [value]
        return self
    def removeValue(self, value):
        self.__value = [x for x in self.__value if x not in value]
        return self.__value
    def getValue(self, value = None):
        return self.__value
    def value_changed(self, value = None):
        return self.__value
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<fieldValue'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        if self.__value is not None:
            if isinstance(self.__value, six.string_types):
                str += ' value="'+self.__value+'"'
            else:
                str += ' value="'+self.__value[0]+'"'
        str += '>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '</fieldValue>'
        return str


class head(object):
    def __init__(self, **kwargs):
        component  = kwargs.pop("component", None)
        self.__component = component
        meta  = kwargs.pop("meta", None)
        self.__meta = meta
        unit  = kwargs.pop("unit", None)
        self.__unit = unit
    @property
    def component(self):
        return self.__component
    @component.setter
    def component(self, value = None):
        self.__component = [value]
    def setComponent(self, component = None):
        self.__component = [component]
        return self
    def addComponent(self, component = None):
        if self.__component == None:            self.__component =  []
        self.__component +=  [component]
        return self
    def removeComponent(self, component):
        self.__component = [x for x in self.__component if x not in component]
        return self.__component
    def getComponent(self, component = None):
        return self.__component
    def component_changed(self, component = None):
        return self.__component
    @property
    def meta(self):
        return self.__meta
    @meta.setter
    def meta(self, value = None):
        self.__meta = [value]
    def setMeta(self, meta = None):
        self.__meta = [meta]
        return self
    def addMeta(self, meta = None):
        if self.__meta == None:            self.__meta =  []
        self.__meta +=  [meta]
        return self
    def removeMeta(self, meta):
        self.__meta = [x for x in self.__meta if x not in meta]
        return self.__meta
    def getMeta(self, meta = None):
        return self.__meta
    def meta_changed(self, meta = None):
        return self.__meta
    @property
    def unit(self):
        return self.__unit
    @unit.setter
    def unit(self, value = None):
        self.__unit = [value]
    def setUnit(self, unit = None):
        self.__unit = [unit]
        return self
    def addUnit(self, unit = None):
        if self.__unit == None:            self.__unit =  []
        self.__unit +=  [unit]
        return self
    def removeUnit(self, unit):
        self.__unit = [x for x in self.__unit if x not in unit]
        return self.__unit
    def getUnit(self, unit = None):
        return self.__unit
    def unit_changed(self, unit = None):
        return self.__unit
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    @property
    def meta(self):
        return self.__meta
    @meta.setter
    def meta(self, value = None):
        self.__meta = [value]
    def setMeta(self, meta = None):
        self.__meta = [meta]
        return self
    def addMeta(self, meta = None):
        if self.__meta == None:            self.__meta =  []
        self.__meta +=  [meta]
        return self
    def removeMeta(self, meta):
        self.__meta = [x for x in self.__meta if x not in meta]
        return self.__meta
    def getMeta(self, meta = None):
        return self.__meta
    def meta_changed(self, meta = None):
        return self.__meta
    def toXML(self):
        str = ''
        str += '<head'
        str += '>'
        str += '<component'
        if self.__component is not None:
           for s in self.__component:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__component is not None:
           for s in self.__component:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</component>'
        str += '<meta'
        if self.__meta is not None:
           for s in self.__meta:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__meta is not None:
           for s in self.__meta:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</meta>'
        str += '<unit'
        if self.__unit is not None:
           for s in self.__unit:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__unit is not None:
           for s in self.__unit:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</unit>'
        str += '</head>'
        return str


class IMPORT(object):
    def __init__(self, **kwargs):
        super(IMPORT, self).__init__()
        AS  = kwargs.pop("AS", None)
        self.__AS = AS
        importedDEF  = kwargs.pop("importedDEF", None)
        self.__importedDEF = importedDEF
        inlineDEF  = kwargs.pop("inlineDEF", None)
        self.__inlineDEF = inlineDEF
    @property
    def AS(self):
        return self.__AS
    @AS.setter
    def AS(self, value = None):
        self.__AS = [value]
    def setAS(self, AS = None):
        self.__AS = [AS]
        return self
    def addAS(self, AS = None):
        if self.__AS == None:            self.__AS =  []
        self.__AS +=  [AS]
        return self
    def removeAS(self, AS):
        self.__AS = [x for x in self.__AS if x not in AS]
        return self.__AS
    def getAS(self, AS = None):
        return self.__AS
    def AS_changed(self, AS = None):
        return self.__AS
    @property
    def importedDEF(self):
        return self.__importedDEF
    @importedDEF.setter
    def importedDEF(self, value = None):
        self.__importedDEF = [value]
    def setImportedDEF(self, importedDEF = None):
        self.__importedDEF = [importedDEF]
        return self
    def addImportedDEF(self, importedDEF = None):
        if self.__importedDEF == None:            self.__importedDEF =  []
        self.__importedDEF +=  [importedDEF]
        return self
    def removeImportedDEF(self, importedDEF):
        self.__importedDEF = [x for x in self.__importedDEF if x not in importedDEF]
        return self.__importedDEF
    def getImportedDEF(self, importedDEF = None):
        return self.__importedDEF
    def importedDEF_changed(self, importedDEF = None):
        return self.__importedDEF
    @property
    def inlineDEF(self):
        return self.__inlineDEF
    @inlineDEF.setter
    def inlineDEF(self, value = None):
        self.__inlineDEF = [value]
    def setInlineDEF(self, inlineDEF = None):
        self.__inlineDEF = [inlineDEF]
        return self
    def addInlineDEF(self, inlineDEF = None):
        if self.__inlineDEF == None:            self.__inlineDEF =  []
        self.__inlineDEF +=  [inlineDEF]
        return self
    def removeInlineDEF(self, inlineDEF):
        self.__inlineDEF = [x for x in self.__inlineDEF if x not in inlineDEF]
        return self.__inlineDEF
    def getInlineDEF(self, inlineDEF = None):
        return self.__inlineDEF
    def inlineDEF_changed(self, inlineDEF = None):
        return self.__inlineDEF
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<IMPORT'
        if self.__AS is not None:
            if isinstance(self.__AS, six.string_types):
                str += ' AS="'+self.__AS+'"'
            else:
                str += ' AS="'+self.__AS[0]+'"'
        if self.__importedDEF is not None:
            if isinstance(self.__importedDEF, six.string_types):
                str += ' importedDEF="'+self.__importedDEF+'"'
            else:
                str += ' importedDEF="'+self.__importedDEF[0]+'"'
        if self.__inlineDEF is not None:
            if isinstance(self.__inlineDEF, six.string_types):
                str += ' inlineDEF="'+self.__inlineDEF+'"'
            else:
                str += ' inlineDEF="'+self.__inlineDEF[0]+'"'
        str += '>'
        str += '</IMPORT>'
        return str


class IS(object):
    def __init__(self, **kwargs):
        super(IS, self).__init__()
        connect  = kwargs.pop("connect", None)
        self.__connect = connect
    @property
    def connect(self):
        return self.__connect
    @connect.setter
    def connect(self, value = None):
        self.__connect = [value]
    def setConnect(self, connect = None):
        self.__connect = [connect]
        return self
    def addConnect(self, connect = None):
        if self.__connect == None:            self.__connect =  []
        self.__connect +=  [connect]
        return self
    def removeConnect(self, connect):
        self.__connect = [x for x in self.__connect if x not in connect]
        return self.__connect
    def getConnect(self, connect = None):
        return self.__connect
    def connect_changed(self, connect = None):
        return self.__connect
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<IS'
        str += '>'
        str += '<connect'
        if self.__connect is not None:
           for s in self.__connect:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__connect is not None:
           for s in self.__connect:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</connect>'
        str += '</IS>'
        return str


class meta(object):
    def __init__(self, **kwargs):
        content  = kwargs.pop("content", None)
        self.__content = content
        dir  = kwargs.pop("dir", None)
        if 'rtl' == dir:
            pass
        elif 'ltr' == dir:
            pass
        else:
            return None
        self.__dir = dir
        http_equiv  = kwargs.pop("http_equiv", None)
        self.__http_equiv = http_equiv
        lang  = kwargs.pop("lang", None)
        self.__lang = lang
        name  = kwargs.pop("name", None)
        self.__name = name
        scheme  = kwargs.pop("scheme", None)
        self.__scheme = scheme
    @property
    def content(self):
        return self.__content
    @content.setter
    def content(self, value = None):
        self.__content = [value]
    def setContent(self, content = None):
        self.__content = [content]
        return self
    def addContent(self, content = None):
        if self.__content == None:            self.__content =  []
        self.__content +=  [content]
        return self
    def removeContent(self, content):
        self.__content = [x for x in self.__content if x not in content]
        return self.__content
    def getContent(self, content = None):
        return self.__content
    def content_changed(self, content = None):
        return self.__content
    @property
    def dir(self):
        return self.__dir
    @dir.setter
    def dir(self, value = None):
        if 'rtl' == value:
            pass
        elif 'ltr' == value:
            pass
        else:
            return None
        self.__dir = [value]
    def setDir(self, dir = None):
        if 'rtl' == dir:
            pass
        elif 'ltr' == dir:
            pass
        else:
            return None
        self.__dir = [dir]
        return self
    def addDir(self, dir = None):
        if 'rtl' == dir:
            pass
        elif 'ltr' == dir:
            pass
        else:
            return None
        if self.__dir == None:            self.__dir =  []
        self.__dir +=  [dir]
        return self
    def removeDir(self, dir):
        self.__dir = [x for x in self.__dir if x not in dir]
        return self.__dir
    def getDir(self, dir = None):
        return self.__dir
    def dir_changed(self, dir = None):
        return self.__dir
    @property
    def http_equiv(self):
        return self.__http_equiv
    @http_equiv.setter
    def http_equiv(self, value = None):
        self.__http_equiv = [value]
    def setHttp_equiv(self, http_equiv = None):
        self.__http_equiv = [http_equiv]
        return self
    def addHttp_equiv(self, http_equiv = None):
        if self.__http_equiv == None:            self.__http_equiv =  []
        self.__http_equiv +=  [http_equiv]
        return self
    def removeHttp_equiv(self, http_equiv):
        self.__http_equiv = [x for x in self.__http_equiv if x not in http_equiv]
        return self.__http_equiv
    def getHttp_equiv(self, http_equiv = None):
        return self.__http_equiv
    def http_equiv_changed(self, http_equiv = None):
        return self.__http_equiv
    @property
    def lang(self):
        return self.__lang
    @lang.setter
    def lang(self, value = None):
        self.__lang = [value]
    def setLang(self, lang = None):
        self.__lang = [lang]
        return self
    def addLang(self, lang = None):
        if self.__lang == None:            self.__lang =  []
        self.__lang +=  [lang]
        return self
    def removeLang(self, lang):
        self.__lang = [x for x in self.__lang if x not in lang]
        return self.__lang
    def getLang(self, lang = None):
        return self.__lang
    def lang_changed(self, lang = None):
        return self.__lang
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        self.__name = [value]
    def setName(self, name = None):
        self.__name = [name]
        return self
    def addName(self, name = None):
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def scheme(self):
        return self.__scheme
    @scheme.setter
    def scheme(self, value = None):
        self.__scheme = [value]
    def setScheme(self, scheme = None):
        self.__scheme = [scheme]
        return self
    def addScheme(self, scheme = None):
        if self.__scheme == None:            self.__scheme =  []
        self.__scheme +=  [scheme]
        return self
    def removeScheme(self, scheme):
        self.__scheme = [x for x in self.__scheme if x not in scheme]
        return self.__scheme
    def getScheme(self, scheme = None):
        return self.__scheme
    def scheme_changed(self, scheme = None):
        return self.__scheme
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<meta'
        if self.__content is not None:
            if isinstance(self.__content, six.string_types):
                str += ' content="'+self.__content+'"'
            else:
                str += ' content="'+self.__content[0]+'"'
        if self.__dir is not None:
            if isinstance(self.__dir, six.string_types):
                str += ' dir="'+self.__dir+'"'
            else:
                str += ' dir="'+self.__dir[0]+'"'
        if self.__http_equiv is not None:
            if isinstance(self.__http_equiv, six.string_types):
                str += ' http_equiv="'+self.__http_equiv+'"'
            else:
                str += ' http_equiv="'+self.__http_equiv[0]+'"'
        if self.__lang is not None:
            if isinstance(self.__lang, six.string_types):
                str += ' lang="'+self.__lang+'"'
            else:
                str += ' lang="'+self.__lang[0]+'"'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        if self.__scheme is not None:
            if isinstance(self.__scheme, six.string_types):
                str += ' scheme="'+self.__scheme+'"'
            else:
                str += ' scheme="'+self.__scheme[0]+'"'
        str += '>'
        str += '</meta>'
        return str


class ProtoBody(object):
    def __init__(self, **kwargs):
        super(ProtoBody, self).__init__()
        children  = kwargs.pop("children", None)
        self.__children = children
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ProtoBody'
        str += '>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '</ProtoBody>'
        return str


class ProtoDeclare(object):
    def __init__(self, **kwargs):
        super(ProtoDeclare, self).__init__()
        appinfo  = kwargs.pop("appinfo", None)
        self.__appinfo = appinfo
        documentation  = kwargs.pop("documentation", None)
        self.__documentation = documentation
        name  = kwargs.pop("name", None)
        self.__name = name
        ProtoBody  = kwargs.pop("ProtoBody", None)
        self.__ProtoBody = ProtoBody
        ProtoInterface  = kwargs.pop("ProtoInterface", None)
        self.__ProtoInterface = ProtoInterface
    @property
    def appinfo(self):
        return self.__appinfo
    @appinfo.setter
    def appinfo(self, value = None):
        self.__appinfo = [value]
    def setAppinfo(self, appinfo = None):
        self.__appinfo = [appinfo]
        return self
    def addAppinfo(self, appinfo = None):
        if self.__appinfo == None:            self.__appinfo =  []
        self.__appinfo +=  [appinfo]
        return self
    def removeAppinfo(self, appinfo):
        self.__appinfo = [x for x in self.__appinfo if x not in appinfo]
        return self.__appinfo
    def getAppinfo(self, appinfo = None):
        return self.__appinfo
    def appinfo_changed(self, appinfo = None):
        return self.__appinfo
    @property
    def documentation(self):
        return self.__documentation
    @documentation.setter
    def documentation(self, value = None):
        self.__documentation = [value]
    def setDocumentation(self, documentation = None):
        self.__documentation = [documentation]
        return self
    def addDocumentation(self, documentation = None):
        if self.__documentation == None:            self.__documentation =  []
        self.__documentation +=  [documentation]
        return self
    def removeDocumentation(self, documentation):
        self.__documentation = [x for x in self.__documentation if x not in documentation]
        return self.__documentation
    def getDocumentation(self, documentation = None):
        return self.__documentation
    def documentation_changed(self, documentation = None):
        return self.__documentation
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        self.__name = [value]
    def setName(self, name = None):
        self.__name = [name]
        return self
    def addName(self, name = None):
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def ProtoBody(self):
        return self.__ProtoBody
    @ProtoBody.setter
    def ProtoBody(self, value = None):
        self.__ProtoBody = [value]
    def setProtoBody(self, ProtoBody = None):
        self.__ProtoBody = [ProtoBody]
        return self
    def addProtoBody(self, ProtoBody = None):
        if self.__ProtoBody == None:            self.__ProtoBody =  []
        self.__ProtoBody +=  [ProtoBody]
        return self
    def removeProtoBody(self, ProtoBody):
        self.__ProtoBody = [x for x in self.__ProtoBody if x not in ProtoBody]
        return self.__ProtoBody
    def getProtoBody(self, ProtoBody = None):
        return self.__ProtoBody
    def ProtoBody_changed(self, ProtoBody = None):
        return self.__ProtoBody
    @property
    def ProtoInterface(self):
        return self.__ProtoInterface
    @ProtoInterface.setter
    def ProtoInterface(self, value = None):
        self.__ProtoInterface = [value]
    def setProtoInterface(self, ProtoInterface = None):
        self.__ProtoInterface = [ProtoInterface]
        return self
    def addProtoInterface(self, ProtoInterface = None):
        if self.__ProtoInterface == None:            self.__ProtoInterface =  []
        self.__ProtoInterface +=  [ProtoInterface]
        return self
    def removeProtoInterface(self, ProtoInterface):
        self.__ProtoInterface = [x for x in self.__ProtoInterface if x not in ProtoInterface]
        return self.__ProtoInterface
    def getProtoInterface(self, ProtoInterface = None):
        return self.__ProtoInterface
    def ProtoInterface_changed(self, ProtoInterface = None):
        return self.__ProtoInterface
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ProtoDeclare'
        if self.__appinfo is not None:
            if isinstance(self.__appinfo, six.string_types):
                str += ' appinfo="'+self.__appinfo+'"'
            else:
                str += ' appinfo="'+self.__appinfo[0]+'"'
        if self.__documentation is not None:
            if isinstance(self.__documentation, six.string_types):
                str += ' documentation="'+self.__documentation+'"'
            else:
                str += ' documentation="'+self.__documentation[0]+'"'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        str += '>'
        str += '<ProtoBody'
        if self.__ProtoBody is not None:
           for s in self.__ProtoBody:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__ProtoBody is not None:
           for s in self.__ProtoBody:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</ProtoBody>'
        str += '<ProtoInterface'
        if self.__ProtoInterface is not None:
           for s in self.__ProtoInterface:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__ProtoInterface is not None:
           for s in self.__ProtoInterface:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</ProtoInterface>'
        str += '</ProtoDeclare>'
        return str


class ProtoInterface(object):
    def __init__(self, **kwargs):
        super(ProtoInterface, self).__init__()
        field  = kwargs.pop("field", None)
        self.__field = field
    @property
    def field(self):
        return self.__field
    @field.setter
    def field(self, value = None):
        self.__field = [value]
    def setField(self, field = None):
        self.__field = [field]
        return self
    def addField(self, field = None):
        if self.__field == None:            self.__field =  []
        self.__field +=  [field]
        return self
    def removeField(self, field):
        self.__field = [x for x in self.__field if x not in field]
        return self.__field
    def getField(self, field = None):
        return self.__field
    def field_changed(self, field = None):
        return self.__field
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ProtoInterface'
        str += '>'
        str += '<field'
        if self.__field is not None:
           for s in self.__field:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__field is not None:
           for s in self.__field:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</field>'
        str += '</ProtoInterface>'
        return str


class ROUTE(object):
    def __init__(self, **kwargs):
        super(ROUTE, self).__init__()
        fromField  = kwargs.pop("fromField", None)
        self.__fromField = fromField
        fromNode  = kwargs.pop("fromNode", None)
        self.__fromNode = fromNode
        toField  = kwargs.pop("toField", None)
        self.__toField = toField
        toNode  = kwargs.pop("toNode", None)
        self.__toNode = toNode
    @property
    def fromField(self):
        return self.__fromField
    @fromField.setter
    def fromField(self, value = None):
        self.__fromField = [value]
    def setFromField(self, fromField = None):
        self.__fromField = [fromField]
        return self
    def addFromField(self, fromField = None):
        if self.__fromField == None:            self.__fromField =  []
        self.__fromField +=  [fromField]
        return self
    def removeFromField(self, fromField):
        self.__fromField = [x for x in self.__fromField if x not in fromField]
        return self.__fromField
    def getFromField(self, fromField = None):
        return self.__fromField
    def fromField_changed(self, fromField = None):
        return self.__fromField
    @property
    def fromNode(self):
        return self.__fromNode
    @fromNode.setter
    def fromNode(self, value = None):
        self.__fromNode = [value]
    def setFromNode(self, fromNode = None):
        self.__fromNode = [fromNode]
        return self
    def addFromNode(self, fromNode = None):
        if self.__fromNode == None:            self.__fromNode =  []
        self.__fromNode +=  [fromNode]
        return self
    def removeFromNode(self, fromNode):
        self.__fromNode = [x for x in self.__fromNode if x not in fromNode]
        return self.__fromNode
    def getFromNode(self, fromNode = None):
        return self.__fromNode
    def fromNode_changed(self, fromNode = None):
        return self.__fromNode
    @property
    def toField(self):
        return self.__toField
    @toField.setter
    def toField(self, value = None):
        self.__toField = [value]
    def setToField(self, toField = None):
        self.__toField = [toField]
        return self
    def addToField(self, toField = None):
        if self.__toField == None:            self.__toField =  []
        self.__toField +=  [toField]
        return self
    def removeToField(self, toField):
        self.__toField = [x for x in self.__toField if x not in toField]
        return self.__toField
    def getToField(self, toField = None):
        return self.__toField
    def toField_changed(self, toField = None):
        return self.__toField
    @property
    def toNode(self):
        return self.__toNode
    @toNode.setter
    def toNode(self, value = None):
        self.__toNode = [value]
    def setToNode(self, toNode = None):
        self.__toNode = [toNode]
        return self
    def addToNode(self, toNode = None):
        if self.__toNode == None:            self.__toNode =  []
        self.__toNode +=  [toNode]
        return self
    def removeToNode(self, toNode):
        self.__toNode = [x for x in self.__toNode if x not in toNode]
        return self.__toNode
    def getToNode(self, toNode = None):
        return self.__toNode
    def toNode_changed(self, toNode = None):
        return self.__toNode
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<ROUTE'
        if self.__fromField is not None:
            if isinstance(self.__fromField, six.string_types):
                str += ' fromField="'+self.__fromField+'"'
            else:
                str += ' fromField="'+self.__fromField[0]+'"'
        if self.__fromNode is not None:
            if isinstance(self.__fromNode, six.string_types):
                str += ' fromNode="'+self.__fromNode+'"'
            else:
                str += ' fromNode="'+self.__fromNode[0]+'"'
        if self.__toField is not None:
            if isinstance(self.__toField, six.string_types):
                str += ' toField="'+self.__toField+'"'
            else:
                str += ' toField="'+self.__toField[0]+'"'
        if self.__toNode is not None:
            if isinstance(self.__toNode, six.string_types):
                str += ' toNode="'+self.__toNode+'"'
            else:
                str += ' toNode="'+self.__toNode[0]+'"'
        str += '>'
        str += '</ROUTE>'
        return str


class Scene(object):
    def __init__(self, **kwargs):
        super(Scene, self).__init__()
        children  = kwargs.pop("children", None)
        self.__children = children
        LayerSet  = kwargs.pop("LayerSet", None)
        self.__LayerSet = LayerSet
    @property
    def children(self):
        return self.__children
    @children.setter
    def children(self, value = None):
        self.__children = [value]
    def setChildren(self, children = None):
        self.__children = [children]
        return self
    def addChildren(self, children = None):
        if self.__children == None:            self.__children =  []
        self.__children +=  [children]
        return self
    def removeChildren(self, children):
        self.__children = [x for x in self.__children if x not in children]
        return self.__children
    def getChildren(self, children = None):
        return self.__children
    def children_changed(self, children = None):
        return self.__children
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    @property
    def LayerSet(self):
        return self.__LayerSet
    @LayerSet.setter
    def LayerSet(self, value = None):
        self.__LayerSet = [value]
    def setLayerSet(self, LayerSet = None):
        self.__LayerSet = [LayerSet]
        return self
    def addLayerSet(self, LayerSet = None):
        if self.__LayerSet == None:            self.__LayerSet =  []
        self.__LayerSet +=  [LayerSet]
        return self
    def removeLayerSet(self, LayerSet):
        self.__LayerSet = [x for x in self.__LayerSet if x not in LayerSet]
        return self.__LayerSet
    def getLayerSet(self, LayerSet = None):
        return self.__LayerSet
    def LayerSet_changed(self, LayerSet = None):
        return self.__LayerSet
    def toXML(self):
        str = ''
        str += '<Scene'
        str += '>'
        str += '<children'
        if self.__children is not None:
           for s in self.__children:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__children is not None:
           for s in self.__children:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</children>'
        str += '</Scene>'
        return str


class unit(object):
    def __init__(self, **kwargs):
        super(unit, self).__init__()
        category  = kwargs.pop("category", None)
        if 'angle' == category:
            pass
        elif 'force' == category:
            pass
        elif 'length' == category:
            pass
        elif 'mass' == category:
            pass
        else:
            return None
        self.__category = category
        conversionFactor  = kwargs.pop("conversionFactor", 1.0)
        if conversionFactor == None or conversionFactor  <=  0:
            return None
        self.__conversionFactor = conversionFactor
        name  = kwargs.pop("name", None)
        self.__name = name
    @property
    def conversionFactor(self):
        return self.__conversionFactor
    @conversionFactor.setter
    def conversionFactor(self, value = 1.0):
        if value == None or value  <=  0:
            return None
        self.__conversionFactor = [value]
    def setConversionFactor(self, conversionFactor = 1.0):
        if conversionFactor == None or conversionFactor  <=  0:
            return None
        self.__conversionFactor = [conversionFactor]
        return self
    def addConversionFactor(self, conversionFactor = 1.0):
        if conversionFactor == None or conversionFactor  <=  0:
            return None
        if self.__conversionFactor == None:            self.__conversionFactor =  []
        self.__conversionFactor +=  [conversionFactor]
        return self
    def removeConversionFactor(self, conversionFactor):
        self.__conversionFactor = [x for x in self.__conversionFactor if x not in conversionFactor]
        return self.__conversionFactor
    def getConversionFactor(self, conversionFactor = 1.0):
        return self.__conversionFactor
    def conversionFactor_changed(self, conversionFactor = 1.0):
        return self.__conversionFactor
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value = None):
        self.__name = [value]
    def setName(self, name = None):
        self.__name = [name]
        return self
    def addName(self, name = None):
        if self.__name == None:            self.__name =  []
        self.__name +=  [name]
        return self
    def removeName(self, name):
        self.__name = [x for x in self.__name if x not in name]
        return self.__name
    def getName(self, name = None):
        return self.__name
    def name_changed(self, name = None):
        return self.__name
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<unit'
        if self.__category is not None:
            if isinstance(self.__category, six.string_types):
                str += ' category="'+self.__category+'"'
            else:
                str += ' category="'+self.__category[0]+'"'
        if self.__conversionFactor is not None:
            if isinstance(self.__conversionFactor, six.string_types):
                str += ' conversionFactor="'+self.__conversionFactor+'"'
            else:
                str += ' conversionFactor="'+self.__conversionFactor[0]+'"'
        if self.__name is not None:
            if isinstance(self.__name, six.string_types):
                str += ' name="'+self.__name+'"'
            else:
                str += ' name="'+self.__name[0]+'"'
        str += '>'
        str += '</unit>'
        return str


class X3D(object):
    def __init__(self, **kwargs):
        head  = kwargs.pop("head", None)
        self.__head = head
        profile  = kwargs.pop("profile", "Immersive")
        if 'Core' == profile:
            pass
        elif 'Interchange' == profile:
            pass
        elif 'CADInterchange' == profile:
            pass
        elif 'Interactive' == profile:
            pass
        elif 'Immersive' == profile:
            pass
        elif 'MedicalInterchange' == profile:
            pass
        elif 'MPEG4Interactive' == profile:
            pass
        elif 'Full' == profile:
            pass
        else:
            return None
        self.__profile = profile
        Scene  = kwargs.pop("Scene", None)
        self.__Scene = Scene
        version  = kwargs.pop("version", "3.3")
        if '3.0' == version:
            pass
        elif '3.1' == version:
            pass
        elif '3.2' == version:
            pass
        elif '3.3' == version:
            pass
        elif '4.0' == version:
            pass
        else:
            return None
        self.__version = version
    @property
    def head(self):
        return self.__head
    @head.setter
    def head(self, value = None):
        self.__head = [value]
    def setHead(self, head = None):
        self.__head = [head]
        return self
    def addHead(self, head = None):
        if self.__head == None:            self.__head =  []
        self.__head +=  [head]
        return self
    def removeHead(self, head):
        self.__head = [x for x in self.__head if x not in head]
        return self.__head
    def getHead(self, head = None):
        return self.__head
    def head_changed(self, head = None):
        return self.__head
    @property
    def profile(self):
        return self.__profile
    @profile.setter
    def profile(self, value = "Immersive"):
        if 'Core' == value:
            pass
        elif 'Interchange' == value:
            pass
        elif 'CADInterchange' == value:
            pass
        elif 'Interactive' == value:
            pass
        elif 'Immersive' == value:
            pass
        elif 'MedicalInterchange' == value:
            pass
        elif 'MPEG4Interactive' == value:
            pass
        elif 'Full' == value:
            pass
        else:
            return None
        self.__profile = [value]
    def setProfile(self, profile = "Immersive"):
        if 'Core' == profile:
            pass
        elif 'Interchange' == profile:
            pass
        elif 'CADInterchange' == profile:
            pass
        elif 'Interactive' == profile:
            pass
        elif 'Immersive' == profile:
            pass
        elif 'MedicalInterchange' == profile:
            pass
        elif 'MPEG4Interactive' == profile:
            pass
        elif 'Full' == profile:
            pass
        else:
            return None
        self.__profile = [profile]
        return self
    def addProfile(self, profile = "Immersive"):
        if 'Core' == profile:
            pass
        elif 'Interchange' == profile:
            pass
        elif 'CADInterchange' == profile:
            pass
        elif 'Interactive' == profile:
            pass
        elif 'Immersive' == profile:
            pass
        elif 'MedicalInterchange' == profile:
            pass
        elif 'MPEG4Interactive' == profile:
            pass
        elif 'Full' == profile:
            pass
        else:
            return None
        if self.__profile == None:            self.__profile =  []
        self.__profile +=  [profile]
        return self
    def removeProfile(self, profile):
        self.__profile = [x for x in self.__profile if x not in profile]
        return self.__profile
    def getProfile(self, profile = "Immersive"):
        return self.__profile
    def profile_changed(self, profile = "Immersive"):
        return self.__profile
    @property
    def Scene(self):
        return self.__Scene
    @Scene.setter
    def Scene(self, value = None):
        self.__Scene = [value]
    def setScene(self, Scene = None):
        self.__Scene = [Scene]
        return self
    def addScene(self, Scene = None):
        if self.__Scene == None:            self.__Scene =  []
        self.__Scene +=  [Scene]
        return self
    def removeScene(self, Scene):
        self.__Scene = [x for x in self.__Scene if x not in Scene]
        return self.__Scene
    def getScene(self, Scene = None):
        return self.__Scene
    def Scene_changed(self, Scene = None):
        return self.__Scene
    @property
    def version(self):
        return self.__version
    @version.setter
    def version(self, value = "3.3"):
        if '3.0' == value:
            pass
        elif '3.1' == value:
            pass
        elif '3.2' == value:
            pass
        elif '3.3' == value:
            pass
        elif '4.0' == value:
            pass
        else:
            return None
        self.__version = [value]
    def setVersion(self, version = "3.3"):
        if '3.0' == version:
            pass
        elif '3.1' == version:
            pass
        elif '3.2' == version:
            pass
        elif '3.3' == version:
            pass
        elif '4.0' == version:
            pass
        else:
            return None
        self.__version = [version]
        return self
    def addVersion(self, version = "3.3"):
        if '3.0' == version:
            pass
        elif '3.1' == version:
            pass
        elif '3.2' == version:
            pass
        elif '3.3' == version:
            pass
        elif '4.0' == version:
            pass
        else:
            return None
        if self.__version == None:            self.__version =  []
        self.__version +=  [version]
        return self
    def removeVersion(self, version):
        self.__version = [x for x in self.__version if x not in version]
        return self.__version
    def getVersion(self, version = "3.3"):
        return self.__version
    def version_changed(self, version = "3.3"):
        return self.__version
    @property
    def comments(self):
        return self.__comments
    @comments.setter
    def comments(self, value = None):
        self.__comments = [value]
    def setComments(self, comments = None):
        self.__comments = [comments]
        return self
    def addComments(self, comments = None):
        if self.__comments == None:            self.__comments =  []
        self.__comments +=  [comments]
        return self
    def toXML(self):
        str = ''
        str += '<X3D'
        if self.__profile is not None:
            if isinstance(self.__profile, six.string_types):
                str += ' profile="'+self.__profile+'"'
            else:
                str += ' profile="'+self.__profile[0]+'"'
        if self.__version is not None:
            if isinstance(self.__version, six.string_types):
                str += ' version="'+self.__version+'"'
            else:
                str += ' version="'+self.__version[0]+'"'
        str += '>'
        str += '<head'
        if self.__head is not None:
           for s in self.__head:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__head is not None:
           for s in self.__head:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</head>'
        str += '<Scene'
        if self.__Scene is not None:
           for s in self.__Scene:
               if type(s) not in ['head', 'Scene']:
                   str += s.toXML()
        str += '>'
        if self.__Scene is not None:
           for s in self.__Scene:
               if type(s) in ['head', 'Scene']:
                   str += s.toXMLNode()
        str += '</Scene>'
        str += '</X3D>'
        return str


class SFBool(object):
    def __init__(self, **kwargs):
        super(SFBool, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<SFBool'
        str += '>'
        str += '</SFBool>'
        return str


class MFBool(object):
    def __init__(self, **kwargs):
        super(MFBool, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<MFBool'
        str += '>'
        str += '</MFBool>'
        return str


class SFColor(object):
    def __init__(self, **kwargs):
        super(SFColor, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<SFColor'
        str += '>'
        str += '</SFColor>'
        return str


class MFColor(object):
    def __init__(self, **kwargs):
        super(MFColor, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<MFColor'
        str += '>'
        str += '</MFColor>'
        return str


class SFColorRGBA(object):
    def __init__(self, **kwargs):
        super(SFColorRGBA, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<SFColorRGBA'
        str += '>'
        str += '</SFColorRGBA>'
        return str


class MFColorRGBA(object):
    def __init__(self, **kwargs):
        super(MFColorRGBA, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<MFColorRGBA'
        str += '>'
        str += '</MFColorRGBA>'
        return str


class SFDouble(object):
    def __init__(self, **kwargs):
        super(SFDouble, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<SFDouble'
        str += '>'
        str += '</SFDouble>'
        return str


class MFDouble(object):
    def __init__(self, **kwargs):
        super(MFDouble, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<MFDouble'
        str += '>'
        str += '</MFDouble>'
        return str


class SFFloat(object):
    def __init__(self, **kwargs):
        super(SFFloat, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<SFFloat'
        str += '>'
        str += '</SFFloat>'
        return str


class MFFloat(object):
    def __init__(self, **kwargs):
        super(MFFloat, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<MFFloat'
        str += '>'
        str += '</MFFloat>'
        return str


class SFImage(object):
    def __init__(self, **kwargs):
        super(SFImage, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<SFImage'
        str += '>'
        str += '</SFImage>'
        return str


class MFImage(object):
    def __init__(self, **kwargs):
        super(MFImage, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<MFImage'
        str += '>'
        str += '</MFImage>'
        return str


class SFInt32(object):
    def __init__(self, **kwargs):
        super(SFInt32, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<SFInt32'
        str += '>'
        str += '</SFInt32>'
        return str


class MFInt32(object):
    def __init__(self, **kwargs):
        super(MFInt32, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<MFInt32'
        str += '>'
        str += '</MFInt32>'
        return str


class SFMatrix3d(object):
    def __init__(self, **kwargs):
        super(SFMatrix3d, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<SFMatrix3d'
        str += '>'
        str += '</SFMatrix3d>'
        return str


class MFMatrix3d(object):
    def __init__(self, **kwargs):
        super(MFMatrix3d, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<MFMatrix3d'
        str += '>'
        str += '</MFMatrix3d>'
        return str


class SFMatrix3f(object):
    def __init__(self, **kwargs):
        super(SFMatrix3f, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<SFMatrix3f'
        str += '>'
        str += '</SFMatrix3f>'
        return str


class MFMatrix3f(object):
    def __init__(self, **kwargs):
        super(MFMatrix3f, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<MFMatrix3f'
        str += '>'
        str += '</MFMatrix3f>'
        return str


class SFMatrix4d(object):
    def __init__(self, **kwargs):
        super(SFMatrix4d, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<SFMatrix4d'
        str += '>'
        str += '</SFMatrix4d>'
        return str


class MFMatrix4d(object):
    def __init__(self, **kwargs):
        super(MFMatrix4d, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<MFMatrix4d'
        str += '>'
        str += '</MFMatrix4d>'
        return str


class SFMatrix4f(object):
    def __init__(self, **kwargs):
        super(SFMatrix4f, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<SFMatrix4f'
        str += '>'
        str += '</SFMatrix4f>'
        return str


class MFMatrix4f(object):
    def __init__(self, **kwargs):
        super(MFMatrix4f, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<MFMatrix4f'
        str += '>'
        str += '</MFMatrix4f>'
        return str


class SFString(object):
    def __init__(self, **kwargs):
        super(SFString, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<SFString'
        str += '>'
        str += '</SFString>'
        return str


class SFNode(object):
    def __init__(self, **kwargs):
        super(SFNode, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<SFNode'
        str += '>'
        str += '</SFNode>'
        return str


class MFNode(object):
    def __init__(self, **kwargs):
        super(MFNode, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<MFNode'
        str += '>'
        str += '</MFNode>'
        return str


class SFRotation(object):
    def __init__(self, **kwargs):
        super(SFRotation, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<SFRotation'
        str += '>'
        str += '</SFRotation>'
        return str


class MFRotation(object):
    def __init__(self, **kwargs):
        super(MFRotation, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<MFRotation'
        str += '>'
        str += '</MFRotation>'
        return str


class MFString(object):
    def __init__(self, **kwargs):
        super(MFString, self).__init__()
    def toXML(self):
        str = ''
        str += '<MFString'
        str += '>'
        str += '</MFString>'
        return str


class SFTime(object):
    def __init__(self, **kwargs):
        super(SFTime, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<SFTime'
        str += '>'
        str += '</SFTime>'
        return str


class MFTime(object):
    def __init__(self, **kwargs):
        super(MFTime, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<MFTime'
        str += '>'
        str += '</MFTime>'
        return str


class SFVec2d(object):
    def __init__(self, **kwargs):
        super(SFVec2d, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<SFVec2d'
        str += '>'
        str += '</SFVec2d>'
        return str


class MFVec2d(object):
    def __init__(self, **kwargs):
        super(MFVec2d, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<MFVec2d'
        str += '>'
        str += '</MFVec2d>'
        return str


class SFVec2f(object):
    def __init__(self, **kwargs):
        super(SFVec2f, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<SFVec2f'
        str += '>'
        str += '</SFVec2f>'
        return str


class MFVec2f(object):
    def __init__(self, **kwargs):
        super(MFVec2f, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<MFVec2f'
        str += '>'
        str += '</MFVec2f>'
        return str


class SFVec3d(object):
    def __init__(self, **kwargs):
        super(SFVec3d, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<SFVec3d'
        str += '>'
        str += '</SFVec3d>'
        return str


class MFVec3d(object):
    def __init__(self, **kwargs):
        super(MFVec3d, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<MFVec3d'
        str += '>'
        str += '</MFVec3d>'
        return str


class SFVec3f(object):
    def __init__(self, **kwargs):
        super(SFVec3f, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<SFVec3f'
        str += '>'
        str += '</SFVec3f>'
        return str


class MFVec3f(object):
    def __init__(self, **kwargs):
        super(MFVec3f, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<MFVec3f'
        str += '>'
        str += '</MFVec3f>'
        return str


class SFVec4d(object):
    def __init__(self, **kwargs):
        super(SFVec4d, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<SFVec4d'
        str += '>'
        str += '</SFVec4d>'
        return str


class MFVec4d(object):
    def __init__(self, **kwargs):
        super(MFVec4d, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<MFVec4d'
        str += '>'
        str += '</MFVec4d>'
        return str


class SFVec4f(object):
    def __init__(self, **kwargs):
        super(SFVec4f, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<SFVec4f'
        str += '>'
        str += '</SFVec4f>'
        return str


class MFVec4f(object):
    def __init__(self, **kwargs):
        super(MFVec4f, self).__init__(**kwargs)
    def toXML(self):
        str = ''
        str += '<MFVec4f'
        str += '>'
        str += '</MFVec4f>'
        return str