python-pivy 0.5.0~v609hg-1 / usr / share / pyshared / pivy / coin.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.4
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.


"""
Pivy is a Coin binding for Python. Coin is a high-level 3D graphics
library with a C++ Application Programming Interface. Coin uses
scene-graph data structures to render real-time graphics suitable for
mostly all kinds of scientific and engineering visualization
applications.
"""


from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_coin', [dirname(__file__)])
        except ImportError:
            import _coin
            return _coin
        if fp is not None:
            try:
                _mod = imp.load_module('_coin', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _coin = swig_import_helper()
    del swig_import_helper
else:
    import _coin
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


def _swig_setattr_nondynamic_method(set):
    def set_attr(self,name,value):
        if (name == "thisown"): return self.this.own(value)
        if hasattr(self,name) or (name == "this"):
            set(self,name,value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr


class charp(object):
    """Proxy of C++ charp class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> charp"""
        this = _coin.new_charp()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_charp
    __del__ = lambda self : None;
    def assign(self, *args):
        """assign(self, char value)"""
        return _coin.charp_assign(self, *args)

    def value(self):
        """value(self) -> char"""
        return _coin.charp_value(self)

    def cast(self):
        """cast(self) -> char"""
        return _coin.charp_cast(self)

    def frompointer(*args):
        """frompointer(char t) -> charp"""
        return _coin.charp_frompointer(*args)

    frompointer = staticmethod(frompointer)
charp_swigregister = _coin.charp_swigregister
charp_swigregister(charp)
cast = _coin.cast

def charp_frompointer(*args):
  """charp_frompointer(char t) -> charp"""
  return _coin.charp_frompointer(*args)

class intp(object):
    """Proxy of C++ intp class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> intp"""
        this = _coin.new_intp()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_intp
    __del__ = lambda self : None;
    def assign(self, *args):
        """assign(self, int value)"""
        return _coin.intp_assign(self, *args)

    def value(self):
        """value(self) -> int"""
        return _coin.intp_value(self)

    def cast(self):
        """cast(self) -> int"""
        return _coin.intp_cast(self)

    def frompointer(*args):
        """frompointer(int t) -> intp"""
        return _coin.intp_frompointer(*args)

    frompointer = staticmethod(frompointer)
intp_swigregister = _coin.intp_swigregister
intp_swigregister(intp)

def intp_frompointer(*args):
  """intp_frompointer(int t) -> intp"""
  return _coin.intp_frompointer(*args)

class longp(object):
    """Proxy of C++ longp class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> longp"""
        this = _coin.new_longp()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_longp
    __del__ = lambda self : None;
    def assign(self, *args):
        """assign(self, long value)"""
        return _coin.longp_assign(self, *args)

    def value(self):
        """value(self) -> long"""
        return _coin.longp_value(self)

    def cast(self):
        """cast(self) -> long"""
        return _coin.longp_cast(self)

    def frompointer(*args):
        """frompointer(long t) -> longp"""
        return _coin.longp_frompointer(*args)

    frompointer = staticmethod(frompointer)
longp_swigregister = _coin.longp_swigregister
longp_swigregister(longp)

def longp_frompointer(*args):
  """longp_frompointer(long t) -> longp"""
  return _coin.longp_frompointer(*args)

class floatp(object):
    """Proxy of C++ floatp class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> floatp"""
        this = _coin.new_floatp()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_floatp
    __del__ = lambda self : None;
    def assign(self, *args):
        """assign(self, float value)"""
        return _coin.floatp_assign(self, *args)

    def value(self):
        """value(self) -> float"""
        return _coin.floatp_value(self)

    def cast(self):
        """cast(self) -> float"""
        return _coin.floatp_cast(self)

    def frompointer(*args):
        """frompointer(float t) -> floatp"""
        return _coin.floatp_frompointer(*args)

    frompointer = staticmethod(frompointer)
floatp_swigregister = _coin.floatp_swigregister
floatp_swigregister(floatp)

def floatp_frompointer(*args):
  """floatp_frompointer(float t) -> floatp"""
  return _coin.floatp_frompointer(*args)

class doublep(object):
    """Proxy of C++ doublep class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> doublep"""
        this = _coin.new_doublep()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_doublep
    __del__ = lambda self : None;
    def assign(self, *args):
        """assign(self, double value)"""
        return _coin.doublep_assign(self, *args)

    def value(self):
        """value(self) -> double"""
        return _coin.doublep_value(self)

    def cast(self):
        """cast(self) -> double"""
        return _coin.doublep_cast(self)

    def frompointer(*args):
        """frompointer(double t) -> doublep"""
        return _coin.doublep_frompointer(*args)

    frompointer = staticmethod(frompointer)
doublep_swigregister = _coin.doublep_swigregister
doublep_swigregister(doublep)

def doublep_frompointer(*args):
  """doublep_frompointer(double t) -> doublep"""
  return _coin.doublep_frompointer(*args)

FALSE = _coin.FALSE
TRUE = _coin.TRUE
HAVE_INTTYPES_H = _coin.HAVE_INTTYPES_H
HAVE_STDINT_H = _coin.HAVE_STDINT_H
HAVE_SYS_TYPES_H = _coin.HAVE_SYS_TYPES_H
HAVE_STDDEF_H = _coin.HAVE_STDDEF_H
HAVE_INT8_T = _coin.HAVE_INT8_T
HAVE_UINT8_T = _coin.HAVE_UINT8_T
HAVE_INT16_T = _coin.HAVE_INT16_T
HAVE_UINT16_T = _coin.HAVE_UINT16_T
HAVE_INT32_T = _coin.HAVE_INT32_T
HAVE_UINT32_T = _coin.HAVE_UINT32_T
HAVE_INT64_T = _coin.HAVE_INT64_T
HAVE_UINT64_T = _coin.HAVE_UINT64_T
HAVE_INTPTR_T = _coin.HAVE_INTPTR_T
HAVE_UINTPTR_T = _coin.HAVE_UINTPTR_T
M_E = _coin.M_E
M_LOG2E = _coin.M_LOG2E
M_LOG10E = _coin.M_LOG10E
M_LN2 = _coin.M_LN2
M_LN10 = _coin.M_LN10
M_PI = _coin.M_PI
M_TWOPI = _coin.M_TWOPI
M_PI_2 = _coin.M_PI_2
M_PI_4 = _coin.M_PI_4
M_3PI_4 = _coin.M_3PI_4
M_SQRTPI = _coin.M_SQRTPI
M_1_PI = _coin.M_1_PI
M_2_PI = _coin.M_2_PI
M_2_SQRTPI = _coin.M_2_SQRTPI
M_SQRT2 = _coin.M_SQRT2
M_SQRT1_2 = _coin.M_SQRT1_2
M_LN2LO = _coin.M_LN2LO
M_LN2HI = _coin.M_LN2HI
M_SQRT3 = _coin.M_SQRT3
M_IVLN10 = _coin.M_IVLN10
M_LOG2_E = _coin.M_LOG2_E
M_INVLN2 = _coin.M_INVLN2
COIN_MAJOR_VERSION = _coin.COIN_MAJOR_VERSION
COIN_MINOR_VERSION = _coin.COIN_MINOR_VERSION
COIN_MICRO_VERSION = _coin.COIN_MICRO_VERSION
COIN_VERSION = _coin.COIN_VERSION
HAVE_HASH_QUOTING = _coin.HAVE_HASH_QUOTING
SUN_CC_4_0_SOTYPE_INIT_BUG = _coin.SUN_CC_4_0_SOTYPE_INIT_BUG
class SbDict(object):
    """Proxy of C++ SbDict class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, int entries = 251) -> SbDict
        __init__(self) -> SbDict
        __init__(self, SbDict srcFrom) -> SbDict
        """
        this = _coin.new_SbDict(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SbDict
    __del__ = lambda self : None;
    def applyToAll(self, *args):
        """
        applyToAll(self,  rtn)
        applyToAll(self,  rtn, void data)
        """
        return _coin.SbDict_applyToAll(self, *args)

    def clear(self):
        """clear(self)"""
        return _coin.SbDict_clear(self)

    def enter(self, *args):
        """enter(self, Key key, void value) -> SbBool"""
        return _coin.SbDict_enter(self, *args)

    def find(self, *args):
        """find(self, Key key, void value) -> SbBool"""
        return _coin.SbDict_find(self, *args)

    def makePList(self, *args):
        """makePList(self, SbPList keys, SbPList values)"""
        return _coin.SbDict_makePList(self, *args)

    def remove(self, *args):
        """remove(self, Key key) -> SbBool"""
        return _coin.SbDict_remove(self, *args)

    def setHashingFunction(self, *args):
        """setHashingFunction(self,  func)"""
        return _coin.SbDict_setHashingFunction(self, *args)

SbDict_swigregister = _coin.SbDict_swigregister
SbDict_swigregister(SbDict)

class SoType(object):
    """Proxy of C++ SoType class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def fromName(*args):
        """fromName(SbName name) -> SoType"""
        return _coin.SoType_fromName(*args)

    fromName = staticmethod(fromName)
    def getName(self):
        """getName(self) -> SbName"""
        return _coin.SoType_getName(self)

    def getParent(self):
        """getParent(self) -> SoType"""
        return _coin.SoType_getParent(self)

    def isDerivedFrom(self, *args):
        """isDerivedFrom(self, SoType type) -> SbBool"""
        return _coin.SoType_isDerivedFrom(self, *args)

    def getAllDerivedFrom(*args):
        """getAllDerivedFrom(SoType type, SoTypeList list) -> int"""
        return _coin.SoType_getAllDerivedFrom(*args)

    getAllDerivedFrom = staticmethod(getAllDerivedFrom)
    def canCreateInstance(self):
        """canCreateInstance(self) -> SbBool"""
        return _coin.SoType_canCreateInstance(self)

    def getData(self):
        """getData(self) -> uint16_t"""
        return _coin.SoType_getData(self)

    def getKey(self):
        """getKey(self) -> int16_t"""
        return _coin.SoType_getKey(self)

    def __eq__(self, *args):
        """__eq__(self, SoType type) -> SbBool"""
        return _coin.SoType___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoType type) -> SbBool"""
        return _coin.SoType___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(self, SoType type) -> SbBool"""
        return _coin.SoType___lt__(self, *args)

    def __le__(self, *args):
        """__le__(self, SoType type) -> SbBool"""
        return _coin.SoType___le__(self, *args)

    def __ge__(self, *args):
        """__ge__(self, SoType type) -> SbBool"""
        return _coin.SoType___ge__(self, *args)

    def __gt__(self, *args):
        """__gt__(self, SoType type) -> SbBool"""
        return _coin.SoType___gt__(self, *args)

    def removeType(*args):
        """removeType(SbName name) -> SbBool"""
        return _coin.SoType_removeType(*args)

    removeType = staticmethod(removeType)
    def init():
        """init()"""
        return _coin.SoType_init()

    init = staticmethod(init)
    def fromKey(*args):
        """fromKey(uint16_t key) -> SoType"""
        return _coin.SoType_fromKey(*args)

    fromKey = staticmethod(fromKey)
    def badType():
        """badType() -> SoType"""
        return _coin.SoType_badType()

    badType = staticmethod(badType)
    def isBad(self):
        """isBad(self) -> SbBool"""
        return _coin.SoType_isBad(self)

    def makeInternal(self):
        """makeInternal(self)"""
        return _coin.SoType_makeInternal(self)

    def isInternal(self):
        """isInternal(self) -> SbBool"""
        return _coin.SoType_isInternal(self)

    def getNumTypes():
        """getNumTypes() -> int"""
        return _coin.SoType_getNumTypes()

    getNumTypes = staticmethod(getNumTypes)
    def getInstantiationMethod(self):
        """getInstantiationMethod(self) -> instantiationMethod"""
        return _coin.SoType_getInstantiationMethod(self)

    def createInstance(self):
        """createInstance(self) -> PyObject"""
        return _coin.SoType_createInstance(self)

    def __init__(self): 
        """__init__(self) -> SoType"""
        this = _coin.new_SoType()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoType
    __del__ = lambda self : None;
SoType_swigregister = _coin.SoType_swigregister
SoType_swigregister(SoType)

def SoType_fromName(*args):
  """SoType_fromName(SbName name) -> SoType"""
  return _coin.SoType_fromName(*args)

def SoType_getAllDerivedFrom(*args):
  """SoType_getAllDerivedFrom(SoType type, SoTypeList list) -> int"""
  return _coin.SoType_getAllDerivedFrom(*args)

def SoType_removeType(*args):
  """SoType_removeType(SbName name) -> SbBool"""
  return _coin.SoType_removeType(*args)

def SoType_init():
  """SoType_init()"""
  return _coin.SoType_init()

def SoType_fromKey(*args):
  """SoType_fromKey(uint16_t key) -> SoType"""
  return _coin.SoType_fromKey(*args)

def SoType_badType():
  """SoType_badType() -> SoType"""
  return _coin.SoType_badType()

def SoType_getNumTypes():
  """SoType_getNumTypes() -> int"""
  return _coin.SoType_getNumTypes()

class SbPList(object):
    """Proxy of C++ SbPList class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, int sizehint = ) -> SbPList
        __init__(self) -> SbPList
        __init__(self, SbPList l) -> SbPList
        """
        this = _coin.new_SbPList(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SbPList
    __del__ = lambda self : None;
    def copy(self, *args):
        """copy(self, SbPList l)"""
        return _coin.SbPList_copy(self, *args)

    def fit(self):
        """fit(self)"""
        return _coin.SbPList_fit(self)

    def append(self, *args):
        """append(self, void item)"""
        return _coin.SbPList_append(self, *args)

    def find(self, *args):
        """find(self, void item) -> int"""
        return _coin.SbPList_find(self, *args)

    def insert(self, *args):
        """insert(self, void item, int insertbefore)"""
        return _coin.SbPList_insert(self, *args)

    def removeItem(self, *args):
        """removeItem(self, void item)"""
        return _coin.SbPList_removeItem(self, *args)

    def remove(self, *args):
        """remove(self, int index)"""
        return _coin.SbPList_remove(self, *args)

    def removeFast(self, *args):
        """removeFast(self, int index)"""
        return _coin.SbPList_removeFast(self, *args)

    def getLength(self):
        """getLength(self) -> int"""
        return _coin.SbPList_getLength(self)

    def truncate(self, *args):
        """
        truncate(self, int length, int fit = 0)
        truncate(self, int length)
        """
        return _coin.SbPList_truncate(self, *args)

    def getArrayPtr(self, start = 0):
        """
        getArrayPtr(self, int start = 0)
        getArrayPtr(self) -> void
        """
        return _coin.SbPList_getArrayPtr(self, start)

    def __eq__(self, *args):
        """__eq__(self, SbPList l) -> int"""
        return _coin.SbPList___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SbPList l) -> int"""
        return _coin.SbPList___ne__(self, *args)

    def get(self, *args):
        """get(self, int index) -> void"""
        return _coin.SbPList_get(self, *args)

    def set(self, *args):
        """set(self, int index, void item)"""
        return _coin.SbPList_set(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> void"""
        return _coin.SbPList___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, void val)"""
        return _coin.SbPList___setitem__(self, *args)

    def __iter__(self):
       for i in range(self.getLength()):
          yield self[i]

SbPList_swigregister = _coin.SbPList_swigregister
SbPList_swigregister(SbPList)

class SbIntList(SbPList):
    """Proxy of C++ SbIntList class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbIntList
        __init__(self, int sizehint) -> SbIntList
        """
        this = _coin.new_SbIntList(*args)
        try: self.this.append(this)
        except: self.this = this
    def append(self, *args):
        """append(self, int item)"""
        return _coin.SbIntList_append(self, *args)

    def find(self, *args):
        """find(self, int item) -> int"""
        return _coin.SbIntList_find(self, *args)

    def insert(self, *args):
        """insert(self, int item, int addbefore)"""
        return _coin.SbIntList_insert(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, int value)"""
        return _coin.SbIntList___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> int"""
        return _coin.SbIntList___getitem__(self, *args)

    def get(self, *args):
        """get(self, int i) -> int"""
        return _coin.SbIntList_get(self, *args)

    __swig_destroy__ = _coin.delete_SbIntList
    __del__ = lambda self : None;
SbIntList_swigregister = _coin.SbIntList_swigregister
SbIntList_swigregister(SbIntList)

class SbString(object):
    """Proxy of C++ SbString class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(self) -> SbString
        __init__(self, char s) -> SbString
        __init__(self, char s, int start, int end) -> SbString
        __init__(self, SbString s) -> SbString
        __init__(self, int digits) -> SbString
        """
        this = _coin.new_SbString(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SbString
    __del__ = lambda self : None;
    def hash(*args):
        """
        hash() -> uint32_t
        hash(char s) -> uint32_t
        """
        return _coin.SbString_hash(*args)

    hash = staticmethod(hash)
    def getLength(self):
        """getLength(self) -> int"""
        return _coin.SbString_getLength(self)

    def makeEmpty(self, freeold = 1):
        """
        makeEmpty(self, SbBool freeold = 1)
        makeEmpty(self)
        """
        return _coin.SbString_makeEmpty(self, freeold)

    def getString(self):
        """getString(self) -> char"""
        return _coin.SbString_getString(self)

    def getSubString(self, *args):
        """
        getSubString(self, int startidx, int endidx = -1) -> SbString
        getSubString(self, int startidx) -> SbString
        """
        return _coin.SbString_getSubString(self, *args)

    def deleteSubString(self, *args):
        """
        deleteSubString(self, int startidx, int endidx = -1)
        deleteSubString(self, int startidx)
        """
        return _coin.SbString_deleteSubString(self, *args)

    def addIntString(self, *args):
        """addIntString(self, int value)"""
        return _coin.SbString_addIntString(self, *args)

    def __iadd__(self, *args):
        """
        __iadd__(self, char s) -> SbString
        __iadd__(self, SbString s) -> SbString
        __iadd__(self, char c) -> SbString
        """
        return _coin.SbString___iadd__(self, *args)

    def compareSubString(self, *args):
        """
        compareSubString(self, char text, int offset = 0) -> int
        compareSubString(self, char text) -> int
        """
        return _coin.SbString_compareSubString(self, *args)

    def sprintf(self, *args):
        """sprintf(self, char formatstr, v(...) *args) -> SbString"""
        return _coin.SbString_sprintf(self, *args)

    def apply(self, *args):
        """apply(self, char func)"""
        return _coin.SbString_apply(self, *args)

    def find(self, *args):
        """find(self, SbString s) -> int"""
        return _coin.SbString_find(self, *args)

    def findAll(self, *args):
        """findAll(self, SbString s, SbIntList found) -> SbBool"""
        return _coin.SbString_findAll(self, *args)

    def lower(self):
        """lower(self) -> SbString"""
        return _coin.SbString_lower(self)

    def upper(self):
        """upper(self) -> SbString"""
        return _coin.SbString_upper(self)

    def __eq__(self, *args):
        """
        __eq__(self, SbString u) -> int
        __eq__(self, char u) -> int
        """
        return _coin.SbString___eq__(self, *args)

    def __nq__(self, *args):
        """
        __nq__(self, SbString u) -> int
        __nq__(self, char u) -> int
        """
        return _coin.SbString___nq__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> char"""
        return _coin.SbString___getitem__(self, *args)

    def __iter__(self):
      return getString().__iter__()

    def __repr__(self, *args):
        """__repr__(self) -> char"""
        return _coin.SbString___repr__(self, *args)

SbString_swigregister = _coin.SbString_swigregister
SbString_swigregister(SbString)

def SbString_hash(*args):
  """
    hash() -> uint32_t
    SbString_hash(char s) -> uint32_t
    """
  return _coin.SbString_hash(*args)

class SbName(object):
    """Proxy of C++ SbName class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(self) -> SbName
        __init__(self, char namestring) -> SbName
        __init__(self, SbString str) -> SbName
        __init__(self, SbName name) -> SbName
        """
        this = _coin.new_SbName(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SbName
    __del__ = lambda self : None;
    def getString(self):
        """getString(self) -> char"""
        return _coin.SbName_getString(self)

    def getLength(self):
        """getLength(self) -> int"""
        return _coin.SbName_getLength(self)

    def isIdentStartChar(*args):
        """isIdentStartChar(char c) -> SbBool"""
        return _coin.SbName_isIdentStartChar(*args)

    isIdentStartChar = staticmethod(isIdentStartChar)
    def isIdentChar(*args):
        """isIdentChar(char c) -> SbBool"""
        return _coin.SbName_isIdentChar(*args)

    isIdentChar = staticmethod(isIdentChar)
    def isBaseNameStartChar(*args):
        """isBaseNameStartChar(char c) -> SbBool"""
        return _coin.SbName_isBaseNameStartChar(*args)

    isBaseNameStartChar = staticmethod(isBaseNameStartChar)
    def isBaseNameChar(*args):
        """isBaseNameChar(char c) -> SbBool"""
        return _coin.SbName_isBaseNameChar(*args)

    isBaseNameChar = staticmethod(isBaseNameChar)
    def empty():
        """empty() -> SbName"""
        return _coin.SbName_empty()

    empty = staticmethod(empty)
    def __eq__(self, *args):
        """
        __eq__(self, SbName u) -> int
        __eq__(self, char u) -> int
        __eq__(self, SbString u) -> int
        """
        return _coin.SbName___eq__(self, *args)

    def __nq__(self, *args):
        """
        __nq__(self, SbName u) -> int
        __nq__(self, char u) -> int
        __nq__(self, SbString u) -> int
        """
        return _coin.SbName___nq__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> char"""
        return _coin.SbName___getitem__(self, *args)

    def __iter__(self):
      return getString().__iter__()

    def __repr__(self, *args):
        """__repr__(self) -> char"""
        return _coin.SbName___repr__(self, *args)

SbName_swigregister = _coin.SbName_swigregister
SbName_swigregister(SbName)

def SbName_isIdentStartChar(*args):
  """SbName_isIdentStartChar(char c) -> SbBool"""
  return _coin.SbName_isIdentStartChar(*args)

def SbName_isIdentChar(*args):
  """SbName_isIdentChar(char c) -> SbBool"""
  return _coin.SbName_isIdentChar(*args)

def SbName_isBaseNameStartChar(*args):
  """SbName_isBaseNameStartChar(char c) -> SbBool"""
  return _coin.SbName_isBaseNameStartChar(*args)

def SbName_isBaseNameChar(*args):
  """SbName_isBaseNameChar(char c) -> SbBool"""
  return _coin.SbName_isBaseNameChar(*args)

def SbName_empty():
  """SbName_empty() -> SbName"""
  return _coin.SbName_empty()

class SoError(object):
    """Proxy of C++ SoError class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoError"""
        this = _coin.new_SoError()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoError
    __del__ = lambda self : None;
    def setHandlerCallback(*args):
        """setHandlerCallback(SoErrorCB func, void data)"""
        return _coin.SoError_setHandlerCallback(*args)

    setHandlerCallback = staticmethod(setHandlerCallback)
    def getHandlerCallback():
        """getHandlerCallback() -> SoErrorCB"""
        return _coin.SoError_getHandlerCallback()

    getHandlerCallback = staticmethod(getHandlerCallback)
    def getHandlerData():
        """getHandlerData() -> void"""
        return _coin.SoError_getHandlerData()

    getHandlerData = staticmethod(getHandlerData)
    def getDebugString(self):
        """getDebugString(self) -> SbString"""
        return _coin.SoError_getDebugString(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoError_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoError_getTypeId(self)

    def isOfType(self, *args):
        """isOfType(self, SoType type) -> SbBool"""
        return _coin.SoError_isOfType(self, *args)

    def post(*args):
        """post(char format, v(...) *args)"""
        return _coin.SoError_post(*args)

    post = staticmethod(post)
    def getString(*args):
        """
        getString(SoNode node) -> SbString
        getString(SoPath path) -> SbString
        getString(SoEngine engine) -> SbString
        """
        return _coin.SoError_getString(*args)

    getString = staticmethod(getString)
    def initClass():
        """initClass()"""
        return _coin.SoError_initClass()

    initClass = staticmethod(initClass)
    def initClasses():
        """initClasses()"""
        return _coin.SoError_initClasses()

    initClasses = staticmethod(initClasses)
SoError_swigregister = _coin.SoError_swigregister
SoError_swigregister(SoError)

def SoError_setHandlerCallback(*args):
  """SoError_setHandlerCallback(SoErrorCB func, void data)"""
  return _coin.SoError_setHandlerCallback(*args)

def SoError_getHandlerCallback():
  """SoError_getHandlerCallback() -> SoErrorCB"""
  return _coin.SoError_getHandlerCallback()

def SoError_getHandlerData():
  """SoError_getHandlerData() -> void"""
  return _coin.SoError_getHandlerData()

def SoError_getClassTypeId():
  """SoError_getClassTypeId() -> SoType"""
  return _coin.SoError_getClassTypeId()

def SoError_post(*args):
  """SoError_post(char format, v(...) *args)"""
  return _coin.SoError_post(*args)

def SoError_getString(*args):
  """
    getString(SoNode node) -> SbString
    getString(SoPath path) -> SbString
    SoError_getString(SoEngine engine) -> SbString
    """
  return _coin.SoError_getString(*args)

def SoError_initClass():
  """SoError_initClass()"""
  return _coin.SoError_initClass()

def SoError_initClasses():
  """SoError_initClasses()"""
  return _coin.SoError_initClasses()

class SoDebugError(SoError):
    """Proxy of C++ SoDebugError class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ERROR = _coin.SoDebugError_ERROR
    WARNING = _coin.SoDebugError_WARNING
    INFO = _coin.SoDebugError_INFO
    def setHandlerCallback(*args):
        """setHandlerCallback(SoErrorCB function, void data)"""
        return _coin.SoDebugError_setHandlerCallback(*args)

    setHandlerCallback = staticmethod(setHandlerCallback)
    def getHandlerCallback():
        """getHandlerCallback() -> SoErrorCB"""
        return _coin.SoDebugError_getHandlerCallback()

    getHandlerCallback = staticmethod(getHandlerCallback)
    def getHandlerData():
        """getHandlerData() -> void"""
        return _coin.SoDebugError_getHandlerData()

    getHandlerData = staticmethod(getHandlerData)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoDebugError_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoDebugError_getTypeId(self)

    def getSeverity(self):
        """getSeverity(self) -> Severity"""
        return _coin.SoDebugError_getSeverity(self)

    def post(*args):
        """post(char source, char format, v(...) *args)"""
        return _coin.SoDebugError_post(*args)

    post = staticmethod(post)
    def postWarning(*args):
        """postWarning(char source, char format, v(...) *args)"""
        return _coin.SoDebugError_postWarning(*args)

    postWarning = staticmethod(postWarning)
    def postInfo(*args):
        """postInfo(char source, char format, v(...) *args)"""
        return _coin.SoDebugError_postInfo(*args)

    postInfo = staticmethod(postInfo)
    def initClass():
        """initClass()"""
        return _coin.SoDebugError_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoDebugError"""
        this = _coin.new_SoDebugError()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoDebugError
    __del__ = lambda self : None;
SoDebugError_swigregister = _coin.SoDebugError_swigregister
SoDebugError_swigregister(SoDebugError)

def SoDebugError_setHandlerCallback(*args):
  """SoDebugError_setHandlerCallback(SoErrorCB function, void data)"""
  return _coin.SoDebugError_setHandlerCallback(*args)

def SoDebugError_getHandlerCallback():
  """SoDebugError_getHandlerCallback() -> SoErrorCB"""
  return _coin.SoDebugError_getHandlerCallback()

def SoDebugError_getHandlerData():
  """SoDebugError_getHandlerData() -> void"""
  return _coin.SoDebugError_getHandlerData()

def SoDebugError_getClassTypeId():
  """SoDebugError_getClassTypeId() -> SoType"""
  return _coin.SoDebugError_getClassTypeId()

def SoDebugError_post(*args):
  """SoDebugError_post(char source, char format, v(...) *args)"""
  return _coin.SoDebugError_post(*args)

def SoDebugError_postWarning(*args):
  """SoDebugError_postWarning(char source, char format, v(...) *args)"""
  return _coin.SoDebugError_postWarning(*args)

def SoDebugError_postInfo(*args):
  """SoDebugError_postInfo(char source, char format, v(...) *args)"""
  return _coin.SoDebugError_postInfo(*args)

def SoDebugError_initClass():
  """SoDebugError_initClass()"""
  return _coin.SoDebugError_initClass()

class SbVec2s(object):
    """Proxy of C++ SbVec2s class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbVec2s
        __init__(self, short v) -> SbVec2s
        __init__(self, short x, short y) -> SbVec2s
        __init__(self, SbVec2us v) -> SbVec2s
        __init__(self, SbVec2b v) -> SbVec2s
        __init__(self, SbVec2i32 v) -> SbVec2s
        __init__(self, SbVec2f v) -> SbVec2s
        __init__(self, SbVec2d v) -> SbVec2s
        """
        this = _coin.new_SbVec2s(*args)
        try: self.this.append(this)
        except: self.this = this
    def setValue(self, *args):
        """
        setValue(self, short v) -> SbVec2s
        setValue(self, short x, short y) -> SbVec2s
        setValue(self, SbVec2us v) -> SbVec2s
        setValue(self, SbVec2b v) -> SbVec2s
        setValue(self, SbVec2i32 v) -> SbVec2s
        setValue(self, SbVec2f v) -> SbVec2s
        setValue(self, SbVec2d v) -> SbVec2s
        """
        return _coin.SbVec2s_setValue(self, *args)

    def getValue(self):
        """getValue(self)"""
        return _coin.SbVec2s_getValue(self)

    def dot(self, *args):
        """dot(self, SbVec2s v) -> int32_t"""
        return _coin.SbVec2s_dot(self, *args)

    def negate(self):
        """negate(self)"""
        return _coin.SbVec2s_negate(self)

    def __imul__(self, *args):
        """
        __imul__(self, int d) -> SbVec2s
        __imul__(self, double d) -> SbVec2s
        """
        return _coin.SbVec2s___imul__(self, *args)

    def __idiv__(self, *args):
        """
        __idiv__(self, int d) -> SbVec2s
        __idiv__(self, double d) -> SbVec2s
        """
        return _coin.SbVec2s___idiv__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, SbVec2s v) -> SbVec2s"""
        return _coin.SbVec2s___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, SbVec2s v) -> SbVec2s"""
        return _coin.SbVec2s___isub__(self, *args)

    def __neg__(self):
        """__neg__(self) -> SbVec2s"""
        return _coin.SbVec2s___neg__(self)

    def output(self, *args):
        """output(self, FILE fp)"""
        return _coin.SbVec2s_output(self, *args)

    def __add__(self, *args):
        """__add__(self, SbVec2s u) -> SbVec2s"""
        return _coin.SbVec2s___add__(self, *args)

    def __sub__(self, *args):
        """__sub__(self, SbVec2s u) -> SbVec2s"""
        return _coin.SbVec2s___sub__(self, *args)

    def __mul__(self, *args):
        """__mul__(self, double d) -> SbVec2s"""
        return _coin.SbVec2s___mul__(self, *args)

    def __rmul__(self, *args):
        """__rmul__(self, double d) -> SbVec2s"""
        return _coin.SbVec2s___rmul__(self, *args)

    def __div__(self, *args):
        """__div__(self, double d) -> SbVec2s"""
        return _coin.SbVec2s___div__(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SbVec2s u) -> int"""
        return _coin.SbVec2s___eq__(self, *args)

    def __nq__(self, *args):
        """__nq__(self, SbVec2s u) -> int"""
        return _coin.SbVec2s___nq__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> short"""
        return _coin.SbVec2s___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, short value)"""
        return _coin.SbVec2s___setitem__(self, *args)

    def __iter__(self):
       for i in range(2):
          yield self[i]
       
    def __len__(self):
          return 2

    __swig_destroy__ = _coin.delete_SbVec2s
    __del__ = lambda self : None;
SbVec2s_swigregister = _coin.SbVec2s_swigregister
SbVec2s_swigregister(SbVec2s)

class SbTime(object):
    """Proxy of C++ SbTime class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbTime
        __init__(self, double sec) -> SbTime
        __init__(self, int32_t sec, long usec) -> SbTime
        __init__(self, timeval tv) -> SbTime
        """
        this = _coin.new_SbTime(*args)
        try: self.this.append(this)
        except: self.this = this
    def getTimeOfDay():
        """getTimeOfDay() -> SbTime"""
        return _coin.SbTime_getTimeOfDay()

    getTimeOfDay = staticmethod(getTimeOfDay)
    def setToTimeOfDay(self):
        """setToTimeOfDay(self)"""
        return _coin.SbTime_setToTimeOfDay(self)

    def zero():
        """zero() -> SbTime"""
        return _coin.SbTime_zero()

    zero = staticmethod(zero)
    def max():
        """max() -> SbTime"""
        return _coin.SbTime_max()

    max = staticmethod(max)
    def maxTime():
        """maxTime() -> SbTime"""
        return _coin.SbTime_maxTime()

    maxTime = staticmethod(maxTime)
    def sleep(*args):
        """sleep(int msec)"""
        return _coin.SbTime_sleep(*args)

    sleep = staticmethod(sleep)
    def setValue(self, *args):
        """
        setValue(self, double sec)
        setValue(self, int32_t sec, long usec)
        setValue(self, timeval tv)
        """
        return _coin.SbTime_setValue(self, *args)

    def setMsecValue(self, *args):
        """setMsecValue(self, unsigned long msec)"""
        return _coin.SbTime_setMsecValue(self, *args)

    def getValue(self, *args):
        """
        getValue(self) -> double
        getValue(self, time_t sec, long usec)
        getValue(self, timeval tv)
        """
        return _coin.SbTime_getValue(self, *args)

    def getMsecValue(self):
        """getMsecValue(self) -> unsigned long"""
        return _coin.SbTime_getMsecValue(self)

    def format(self, fmt = "%S.%i"):
        """
        format(self, char fmt = "%S.%i") -> SbString
        format(self) -> SbString
        """
        return _coin.SbTime_format(self, fmt)

    def formatDate(self, fmt = None):
        """
        formatDate(self, char fmt = None) -> SbString
        formatDate(self) -> SbString
        """
        return _coin.SbTime_formatDate(self, fmt)

    def parsedate(self, *args):
        """parsedate(self, char date) -> SbBool"""
        return _coin.SbTime_parsedate(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, SbTime tm) -> SbTime"""
        return _coin.SbTime___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, SbTime tm) -> SbTime"""
        return _coin.SbTime___isub__(self, *args)

    def __neg__(self):
        """__neg__(self) -> SbTime"""
        return _coin.SbTime___neg__(self)

    def __imul__(self, *args):
        """__imul__(self, double s) -> SbTime"""
        return _coin.SbTime___imul__(self, *args)

    def __idiv__(self, *args):
        """__idiv__(self, double s) -> SbTime"""
        return _coin.SbTime___idiv__(self, *args)

    def __mod__(self, *args):
        """__mod__(self, SbTime tm) -> SbTime"""
        return _coin.SbTime___mod__(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SbTime tm) -> int"""
        return _coin.SbTime___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SbTime tm) -> int"""
        return _coin.SbTime___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(self, SbTime tm) -> SbBool"""
        return _coin.SbTime___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(self, SbTime tm) -> SbBool"""
        return _coin.SbTime___gt__(self, *args)

    def __le__(self, *args):
        """__le__(self, SbTime tm) -> SbBool"""
        return _coin.SbTime___le__(self, *args)

    def __ge__(self, *args):
        """__ge__(self, SbTime tm) -> SbBool"""
        return _coin.SbTime___ge__(self, *args)

    def output(self, *args):
        """output(self, FILE fp)"""
        return _coin.SbTime_output(self, *args)

    def __add__(self, *args):
        """__add__(self, SbTime u) -> SbTime"""
        return _coin.SbTime___add__(self, *args)

    def __sub__(self, *args):
        """__sub__(self, SbTime u) -> SbTime"""
        return _coin.SbTime___sub__(self, *args)

    def __mul__(self, *args):
        """__mul__(self, double d) -> SbTime"""
        return _coin.SbTime___mul__(self, *args)

    def __rmul__(self, *args):
        """__rmul__(self, double d) -> SbTime"""
        return _coin.SbTime___rmul__(self, *args)

    def __div__(self, *args):
        """
        __div__(self, SbTime tm) -> double
        __div__(self, double d) -> SbTime
        """
        return _coin.SbTime___div__(self, *args)

    __swig_destroy__ = _coin.delete_SbTime
    __del__ = lambda self : None;
SbTime_swigregister = _coin.SbTime_swigregister
SbTime_swigregister(SbTime)

def SbTime_getTimeOfDay():
  """SbTime_getTimeOfDay() -> SbTime"""
  return _coin.SbTime_getTimeOfDay()

def SbTime_zero():
  """SbTime_zero() -> SbTime"""
  return _coin.SbTime_zero()

def SbTime_max():
  """SbTime_max() -> SbTime"""
  return _coin.SbTime_max()

def SbTime_maxTime():
  """SbTime_maxTime() -> SbTime"""
  return _coin.SbTime_maxTime()

def SbTime_sleep(*args):
  """SbTime_sleep(int msec)"""
  return _coin.SbTime_sleep(*args)

class SoEvent(object):
    """Proxy of C++ SoEvent class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoEvent"""
        this = _coin.new_SoEvent()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoEvent
    __del__ = lambda self : None;
    def isOfType(self, *args):
        """isOfType(self, SoType type) -> SbBool"""
        return _coin.SoEvent_isOfType(self, *args)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoEvent_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoEvent_getTypeId(self)

    def setTime(self, *args):
        """setTime(self, SbTime t)"""
        return _coin.SoEvent_setTime(self, *args)

    def getTime(self):
        """getTime(self) -> SbTime"""
        return _coin.SoEvent_getTime(self)

    def setPosition(self, *args):
        """setPosition(self, SbVec2s p)"""
        return _coin.SoEvent_setPosition(self, *args)

    def getPosition(self, *args):
        """
        getPosition(self) -> SbVec2s
        getPosition(self, SbViewportRegion vpRgn) -> SbVec2s
        """
        return _coin.SoEvent_getPosition(self, *args)

    def getNormalizedPosition(self, *args):
        """getNormalizedPosition(self, SbViewportRegion vpRgn) -> SbVec2f"""
        return _coin.SoEvent_getNormalizedPosition(self, *args)

    def setShiftDown(self, *args):
        """setShiftDown(self, SbBool isDown)"""
        return _coin.SoEvent_setShiftDown(self, *args)

    def wasShiftDown(self):
        """wasShiftDown(self) -> SbBool"""
        return _coin.SoEvent_wasShiftDown(self)

    def setCtrlDown(self, *args):
        """setCtrlDown(self, SbBool isDown)"""
        return _coin.SoEvent_setCtrlDown(self, *args)

    def wasCtrlDown(self):
        """wasCtrlDown(self) -> SbBool"""
        return _coin.SoEvent_wasCtrlDown(self)

    def setAltDown(self, *args):
        """setAltDown(self, SbBool isDown)"""
        return _coin.SoEvent_setAltDown(self, *args)

    def wasAltDown(self):
        """wasAltDown(self) -> SbBool"""
        return _coin.SoEvent_wasAltDown(self)

    def initClass():
        """initClass()"""
        return _coin.SoEvent_initClass()

    initClass = staticmethod(initClass)
SoEvent_swigregister = _coin.SoEvent_swigregister
SoEvent_swigregister(SoEvent)

def SoEvent_getClassTypeId():
  """SoEvent_getClassTypeId() -> SoType"""
  return _coin.SoEvent_getClassTypeId()

def SoEvent_initClass():
  """SoEvent_initClass()"""
  return _coin.SoEvent_initClass()

class SoNotRec(object):
    """Proxy of C++ SoNotRec class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    CONTAINER = _coin.SoNotRec_CONTAINER
    PARENT = _coin.SoNotRec_PARENT
    SENSOR = _coin.SoNotRec_SENSOR
    FIELD = _coin.SoNotRec_FIELD
    ENGINE = _coin.SoNotRec_ENGINE
    def __init__(self, *args): 
        """__init__(self, SoBase notifbase) -> SoNotRec"""
        this = _coin.new_SoNotRec(*args)
        try: self.this.append(this)
        except: self.this = this
    def setType(self, *args):
        """setType(self, Type type)"""
        return _coin.SoNotRec_setType(self, *args)

    def getBase(self):
        """getBase(self) -> SoBase"""
        return _coin.SoNotRec_getBase(self)

    def getType(self):
        """getType(self) -> Type"""
        return _coin.SoNotRec_getType(self)

    def getPrevious(self):
        """getPrevious(self) -> SoNotRec"""
        return _coin.SoNotRec_getPrevious(self)

    def setPrevious(self, *args):
        """setPrevious(self, SoNotRec prev)"""
        return _coin.SoNotRec_setPrevious(self, *args)

    def output(self, *args):
        """output(self, FILE file)"""
        return _coin.SoNotRec_output(self, *args)

    __swig_destroy__ = _coin.delete_SoNotRec
    __del__ = lambda self : None;
SoNotRec_swigregister = _coin.SoNotRec_swigregister
SoNotRec_swigregister(SoNotRec)

class SoNotList(object):
    """Proxy of C++ SoNotList class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SoNotList
        __init__(self, SoNotList nl) -> SoNotList
        """
        this = _coin.new_SoNotList(*args)
        try: self.this.append(this)
        except: self.this = this
    def append(self, *args):
        """
        append(self, SoNotRec rec)
        append(self, SoNotRec rec, SoField field)
        append(self, SoNotRec rec, SoEngineOutput engineout)
        """
        return _coin.SoNotList_append(self, *args)

    def setLastType(self, *args):
        """setLastType(self, Type type)"""
        return _coin.SoNotList_setLastType(self, *args)

    def getFirstRec(self):
        """getFirstRec(self) -> SoNotRec"""
        return _coin.SoNotList_getFirstRec(self)

    def getLastRec(self):
        """getLastRec(self) -> SoNotRec"""
        return _coin.SoNotList_getLastRec(self)

    def getFirstRecAtNode(self):
        """getFirstRecAtNode(self) -> SoNotRec"""
        return _coin.SoNotList_getFirstRecAtNode(self)

    def getLastField(self):
        """getLastField(self) -> SoField"""
        return _coin.SoNotList_getLastField(self)

    def getLastEngineOutput(self):
        """getLastEngineOutput(self) -> SoEngineOutput"""
        return _coin.SoNotList_getLastEngineOutput(self)

    def getTimeStamp(self):
        """getTimeStamp(self) -> uint32_t"""
        return _coin.SoNotList_getTimeStamp(self)

    def output(self, *args):
        """
        output(self, FILE file = stdout)
        output(self)
        """
        return _coin.SoNotList_output(self, *args)

    __swig_destroy__ = _coin.delete_SoNotList
    __del__ = lambda self : None;
SoNotList_swigregister = _coin.SoNotList_swigregister
SoNotList_swigregister(SoNotList)

class SoField(object):
    """Proxy of C++ SoField class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _coin.delete_SoField
    __del__ = lambda self : None;
    def initClass():
        """initClass()"""
        return _coin.SoField_initClass()

    initClass = staticmethod(initClass)
    def initClasses():
        """initClasses()"""
        return _coin.SoField_initClasses()

    initClasses = staticmethod(initClasses)
    def cleanupClass():
        """cleanupClass()"""
        return _coin.SoField_cleanupClass()

    cleanupClass = staticmethod(cleanupClass)
    def setIgnored(self, *args):
        """setIgnored(self, SbBool ignore)"""
        return _coin.SoField_setIgnored(self, *args)

    def isIgnored(self):
        """isIgnored(self) -> SbBool"""
        return _coin.SoField_isIgnored(self)

    def setDefault(self, *args):
        """setDefault(self, SbBool defaultVal)"""
        return _coin.SoField_setDefault(self, *args)

    def isDefault(self):
        """isDefault(self) -> SbBool"""
        return _coin.SoField_isDefault(self)

    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoField_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoField_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def isOfType(self, *args):
        """isOfType(self, SoType type) -> SbBool"""
        return _coin.SoField_isOfType(self, *args)

    def enableConnection(self, *args):
        """enableConnection(self, SbBool flag)"""
        return _coin.SoField_enableConnection(self, *args)

    def isConnectionEnabled(self):
        """isConnectionEnabled(self) -> SbBool"""
        return _coin.SoField_isConnectionEnabled(self)

    def isConnectedFromEngine(self):
        """isConnectedFromEngine(self) -> SbBool"""
        return _coin.SoField_isConnectedFromEngine(self)

    def getConnectedEngine(self, *args):
        """getConnectedEngine(self, SoEngineOutput master) -> SbBool"""
        return _coin.SoField_getConnectedEngine(self, *args)

    def connectFrom(self, *args):
        """
        connectFrom(self, SoEngineOutput master, SbBool notnotify = 0, SbBool append = 0) -> SbBool
        connectFrom(self, SoEngineOutput master, SbBool notnotify = 0) -> SbBool
        connectFrom(self, SoEngineOutput master) -> SbBool
        connectFrom(self, SoField master, SbBool notnotify = 0, SbBool append = 0) -> SbBool
        connectFrom(self, SoField master, SbBool notnotify = 0) -> SbBool
        connectFrom(self, SoField master) -> SbBool
        """
        return _coin.SoField_connectFrom(self, *args)

    def appendConnection(self, *args):
        """
        appendConnection(self, SoEngineOutput master, SbBool notnotify = 0) -> SbBool
        appendConnection(self, SoEngineOutput master) -> SbBool
        appendConnection(self, SoField master, SbBool notnotify = 0) -> SbBool
        appendConnection(self, SoField master) -> SbBool
        """
        return _coin.SoField_appendConnection(self, *args)

    def isConnectedFromField(self):
        """isConnectedFromField(self) -> SbBool"""
        return _coin.SoField_isConnectedFromField(self)

    def getConnectedField(self, *args):
        """getConnectedField(self, SoField master) -> SbBool"""
        return _coin.SoField_getConnectedField(self, *args)

    def getNumConnections(self):
        """getNumConnections(self) -> int"""
        return _coin.SoField_getNumConnections(self)

    def getForwardConnections(self, *args):
        """getForwardConnections(self, SoFieldList slavelist) -> int"""
        return _coin.SoField_getForwardConnections(self, *args)

    def getConnections(self, *args):
        """getConnections(self, SoFieldList masterlist) -> int"""
        return _coin.SoField_getConnections(self, *args)

    def disconnect(self, *args):
        """
        disconnect(self, SoEngineOutput engineoutput)
        disconnect(self, SoField field)
        disconnect(self)
        """
        return _coin.SoField_disconnect(self, *args)

    def isConnected(self):
        """isConnected(self) -> SbBool"""
        return _coin.SoField_isConnected(self)

    def setContainer(self, *args):
        """setContainer(self, SoFieldContainer cont)"""
        return _coin.SoField_setContainer(self, *args)

    def getContainer(self):
        """getContainer(self) -> SoFieldContainer"""
        return _coin.SoField_getContainer(self)

    def set(self, *args):
        """set(self, char valuestring) -> SbBool"""
        return _coin.SoField_set(self, *args)

    def shouldWrite(self):
        """shouldWrite(self) -> SbBool"""
        return _coin.SoField_shouldWrite(self)

    def touch(self):
        """touch(self)"""
        return _coin.SoField_touch(self)

    def startNotify(self):
        """startNotify(self)"""
        return _coin.SoField_startNotify(self)

    def notify(self, *args):
        """notify(self, SoNotList nlist)"""
        return _coin.SoField_notify(self, *args)

    def enableNotify(self, *args):
        """enableNotify(self, SbBool on) -> SbBool"""
        return _coin.SoField_enableNotify(self, *args)

    def isNotifyEnabled(self):
        """isNotifyEnabled(self) -> SbBool"""
        return _coin.SoField_isNotifyEnabled(self)

    def addAuditor(self, *args):
        """addAuditor(self, void f, Type type)"""
        return _coin.SoField_addAuditor(self, *args)

    def removeAuditor(self, *args):
        """removeAuditor(self, void f, Type type)"""
        return _coin.SoField_removeAuditor(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoField f) -> int"""
        return _coin.SoField___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoField f) -> int"""
        return _coin.SoField___ne__(self, *args)

    def connectionStatusChanged(self, *args):
        """connectionStatusChanged(self, int numconnections)"""
        return _coin.SoField_connectionStatusChanged(self, *args)

    def isReadOnly(self):
        """isReadOnly(self) -> SbBool"""
        return _coin.SoField_isReadOnly(self)

    def isSame(self, *args):
        """isSame(self, SoField f) -> SbBool"""
        return _coin.SoField_isSame(self, *args)

    def copyFrom(self, *args):
        """copyFrom(self, SoField f)"""
        return _coin.SoField_copyFrom(self, *args)

    def fixCopy(self, *args):
        """fixCopy(self, SbBool copyconnections)"""
        return _coin.SoField_fixCopy(self, *args)

    def referencesCopy(self):
        """referencesCopy(self) -> SbBool"""
        return _coin.SoField_referencesCopy(self)

    def copyConnection(self, *args):
        """copyConnection(self, SoField fromfield)"""
        return _coin.SoField_copyConnection(self, *args)

    def read(self, *args):
        """read(self, SoInput input, SbName name) -> SbBool"""
        return _coin.SoField_read(self, *args)

    def write(self, *args):
        """write(self, SoOutput out, SbName name)"""
        return _coin.SoField_write(self, *args)

    def countWriteRefs(self, *args):
        """countWriteRefs(self, SoOutput out)"""
        return _coin.SoField_countWriteRefs(self, *args)

    NORMAL_FIELD = _coin.SoField_NORMAL_FIELD
    EVENTIN_FIELD = _coin.SoField_EVENTIN_FIELD
    EVENTOUT_FIELD = _coin.SoField_EVENTOUT_FIELD
    EXPOSED_FIELD = _coin.SoField_EXPOSED_FIELD
    def setFieldType(self, *args):
        """setFieldType(self, int type)"""
        return _coin.SoField_setFieldType(self, *args)

    def getFieldType(self):
        """getFieldType(self) -> int"""
        return _coin.SoField_getFieldType(self)

    def getDirty(self):
        """getDirty(self) -> SbBool"""
        return _coin.SoField_getDirty(self)

    def setDirty(self, *args):
        """setDirty(self, SbBool dirty)"""
        return _coin.SoField_setDirty(self, *args)

    def evaluate(self):
        """evaluate(self)"""
        return _coin.SoField_evaluate(self)

    def get(self):
        """get(self) -> SbString"""
        return _coin.SoField_get(self)

SoField_swigregister = _coin.SoField_swigregister
SoField_swigregister(SoField)

def SoField_initClass():
  """SoField_initClass()"""
  return _coin.SoField_initClass()

def SoField_initClasses():
  """SoField_initClasses()"""
  return _coin.SoField_initClasses()

def SoField_cleanupClass():
  """SoField_cleanupClass()"""
  return _coin.SoField_cleanupClass()

def SoField_getClassTypeId():
  """SoField_getClassTypeId() -> SoType"""
  return _coin.SoField_getClassTypeId()

class SoSField(SoField):
    """Proxy of C++ SoSField class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _coin.delete_SoSField
    __del__ = lambda self : None;
    def initClass():
        """initClass()"""
        return _coin.SoSField_initClass()

    initClass = staticmethod(initClass)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSField_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def atexit_cleanup():
        """atexit_cleanup()"""
        return _coin.SoSField_atexit_cleanup()

    atexit_cleanup = staticmethod(atexit_cleanup)
SoSField_swigregister = _coin.SoSField_swigregister
SoSField_swigregister(SoSField)

def SoSField_initClass():
  """SoSField_initClass()"""
  return _coin.SoSField_initClass()

def SoSField_getClassTypeId():
  """SoSField_getClassTypeId() -> SoType"""
  return _coin.SoSField_getClassTypeId()

def SoSField_atexit_cleanup():
  """SoSField_atexit_cleanup()"""
  return _coin.SoSField_atexit_cleanup()

class SoMField(SoField):
    """Proxy of C++ SoMField class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _coin.delete_SoMField
    __del__ = lambda self : None;
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMField_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def atexit_cleanup():
        """atexit_cleanup()"""
        return _coin.SoMField_atexit_cleanup()

    atexit_cleanup = staticmethod(atexit_cleanup)
    def getNum(self):
        """getNum(self) -> int"""
        return _coin.SoMField_getNum(self)

    def setNum(self, *args):
        """setNum(self, int num)"""
        return _coin.SoMField_setNum(self, *args)

    def deleteValues(self, *args):
        """
        deleteValues(self, int start, int num = -1)
        deleteValues(self, int start)
        """
        return _coin.SoMField_deleteValues(self, *args)

    def insertSpace(self, *args):
        """insertSpace(self, int start, int num)"""
        return _coin.SoMField_insertSpace(self, *args)

    def set1(self, *args):
        """set1(self, int index, char valuestring) -> SbBool"""
        return _coin.SoMField_set1(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMField_initClass()

    initClass = staticmethod(initClass)
    def enableDeleteValues(self):
        """enableDeleteValues(self)"""
        return _coin.SoMField_enableDeleteValues(self)

    def isDeleteValuesEnabled(self):
        """isDeleteValuesEnabled(self) -> SbBool"""
        return _coin.SoMField_isDeleteValuesEnabled(self)

    def __iter__(self):
       i = 0
       while i < self.getNum():
          yield self[i]
          i += 1

    def __len__(self, *args):
        """__len__(self) -> int"""
        return _coin.SoMField___len__(self, *args)

    def get1(self, *args):
        """get1(self, int index) -> SbString"""
        return _coin.SoMField_get1(self, *args)

SoMField_swigregister = _coin.SoMField_swigregister
SoMField_swigregister(SoMField)

def SoMField_getClassTypeId():
  """SoMField_getClassTypeId() -> SoType"""
  return _coin.SoMField_getClassTypeId()

def SoMField_atexit_cleanup():
  """SoMField_atexit_cleanup()"""
  return _coin.SoMField_atexit_cleanup()

def SoMField_initClass():
  """SoMField_initClass()"""
  return _coin.SoMField_initClass()

class SoAuditorList(object):
    """Proxy of C++ SoAuditorList class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoAuditorList"""
        this = _coin.new_SoAuditorList()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoAuditorList
    __del__ = lambda self : None;
    def append(self, *args):
        """append(self, void auditor, Type type)"""
        return _coin.SoAuditorList_append(self, *args)

    def set(self, *args):
        """set(self, int index, void auditor, Type type)"""
        return _coin.SoAuditorList_set(self, *args)

    def getObject(self, *args):
        """getObject(self, int index) -> void"""
        return _coin.SoAuditorList_getObject(self, *args)

    def getType(self, *args):
        """getType(self, int index) -> Type"""
        return _coin.SoAuditorList_getType(self, *args)

    def getLength(self):
        """getLength(self) -> int"""
        return _coin.SoAuditorList_getLength(self)

    def find(self, *args):
        """find(self, void auditor, Type type) -> int"""
        return _coin.SoAuditorList_find(self, *args)

    def remove(self, *args):
        """
        remove(self, int index)
        remove(self, void auditor, Type type)
        """
        return _coin.SoAuditorList_remove(self, *args)

    def notify(self, *args):
        """notify(self, SoNotList l)"""
        return _coin.SoAuditorList_notify(self, *args)

SoAuditorList_swigregister = _coin.SoAuditorList_swigregister
SoAuditorList_swigregister(SoAuditorList)

class SoBase(object):
    """Proxy of C++ SoBase class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def initClass():
        """initClass()"""
        return _coin.SoBase_initClass()

    initClass = staticmethod(initClass)
    def ref(self):
        """ref(self)"""
        return _coin.SoBase_ref(self)

    def unref(self):
        """unref(self)"""
        return _coin.SoBase_unref(self)

    def unrefNoDelete(self):
        """unrefNoDelete(self)"""
        return _coin.SoBase_unrefNoDelete(self)

    def getRefCount(self):
        """getRefCount(self) -> int32_t"""
        return _coin.SoBase_getRefCount(self)

    def touch(self):
        """touch(self)"""
        return _coin.SoBase_touch(self)

    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoBase_getTypeId(self)

    def isOfType(self, *args):
        """isOfType(self, SoType type) -> SbBool"""
        return _coin.SoBase_isOfType(self, *args)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoBase_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getName(self):
        """getName(self) -> SbName"""
        return _coin.SoBase_getName(self)

    def setName(self, *args):
        """setName(self, SbName newname)"""
        return _coin.SoBase_setName(self, *args)

    def addName(*args):
        """addName(SoBase base, char name)"""
        return _coin.SoBase_addName(*args)

    addName = staticmethod(addName)
    def removeName(*args):
        """removeName(SoBase base, char name)"""
        return _coin.SoBase_removeName(*args)

    removeName = staticmethod(removeName)
    def startNotify(self):
        """startNotify(self)"""
        return _coin.SoBase_startNotify(self)

    def notify(self, *args):
        """notify(self, SoNotList l)"""
        return _coin.SoBase_notify(self, *args)

    def addAuditor(self, *args):
        """addAuditor(self, void auditor, Type type)"""
        return _coin.SoBase_addAuditor(self, *args)

    def removeAuditor(self, *args):
        """removeAuditor(self, void auditor, Type type)"""
        return _coin.SoBase_removeAuditor(self, *args)

    def getAuditors(self):
        """getAuditors(self) -> SoAuditorList"""
        return _coin.SoBase_getAuditors(self)

    def addWriteReference(self, *args):
        """
        addWriteReference(self, SoOutput out, SbBool isfromfield = 0)
        addWriteReference(self, SoOutput out)
        """
        return _coin.SoBase_addWriteReference(self, *args)

    def shouldWrite(self):
        """shouldWrite(self) -> SbBool"""
        return _coin.SoBase_shouldWrite(self)

    def incrementCurrentWriteCounter():
        """incrementCurrentWriteCounter()"""
        return _coin.SoBase_incrementCurrentWriteCounter()

    incrementCurrentWriteCounter = staticmethod(incrementCurrentWriteCounter)
    def decrementCurrentWriteCounter():
        """decrementCurrentWriteCounter()"""
        return _coin.SoBase_decrementCurrentWriteCounter()

    decrementCurrentWriteCounter = staticmethod(decrementCurrentWriteCounter)
    def getNamedBase(*args):
        """getNamedBase(SbName name, SoType type) -> SoBase"""
        return _coin.SoBase_getNamedBase(*args)

    getNamedBase = staticmethod(getNamedBase)
    def getNamedBases(*args):
        """getNamedBases(SbName name, SoBaseList baselist, SoType type) -> int"""
        return _coin.SoBase_getNamedBases(*args)

    getNamedBases = staticmethod(getNamedBases)
    def read(*args):
        """read(SoInput input, SoBase base, SoType expectedtype) -> SbBool"""
        return _coin.SoBase_read(*args)

    read = staticmethod(read)
    def setInstancePrefix(*args):
        """setInstancePrefix(SbString c)"""
        return _coin.SoBase_setInstancePrefix(*args)

    setInstancePrefix = staticmethod(setInstancePrefix)
    def setTraceRefs(*args):
        """setTraceRefs(SbBool trace)"""
        return _coin.SoBase_setTraceRefs(*args)

    setTraceRefs = staticmethod(setTraceRefs)
    def getTraceRefs():
        """getTraceRefs() -> SbBool"""
        return _coin.SoBase_getTraceRefs()

    getTraceRefs = staticmethod(getTraceRefs)
    def connectRoute(*args):
        """
        connectRoute(SoInput input, SbName fromnodename, SbName fromfieldname, 
            SbName tonodename, SbName tofieldname) -> SbBool
        """
        return _coin.SoBase_connectRoute(*args)

    connectRoute = staticmethod(connectRoute)
    def assertAlive(self):
        """assertAlive(self)"""
        return _coin.SoBase_assertAlive(self)

    def readRoute(*args):
        """readRoute(SoInput input) -> SbBool"""
        return _coin.SoBase_readRoute(*args)

    readRoute = staticmethod(readRoute)
    __swig_destroy__ = _coin.delete_SoBase
    __del__ = lambda self : None;
    def __eq__(self,other):
      return other and (self.this == other.this) or False
    def __ne__(self,other):
      return other and (self.this != other.this) or True
    def __nonzero__(self):
      return True

SoBase_swigregister = _coin.SoBase_swigregister
SoBase_swigregister(SoBase)

def SoBase_initClass():
  """SoBase_initClass()"""
  return _coin.SoBase_initClass()

def SoBase_getClassTypeId():
  """SoBase_getClassTypeId() -> SoType"""
  return _coin.SoBase_getClassTypeId()

def SoBase_addName(*args):
  """SoBase_addName(SoBase base, char name)"""
  return _coin.SoBase_addName(*args)

def SoBase_removeName(*args):
  """SoBase_removeName(SoBase base, char name)"""
  return _coin.SoBase_removeName(*args)

def SoBase_incrementCurrentWriteCounter():
  """SoBase_incrementCurrentWriteCounter()"""
  return _coin.SoBase_incrementCurrentWriteCounter()

def SoBase_decrementCurrentWriteCounter():
  """SoBase_decrementCurrentWriteCounter()"""
  return _coin.SoBase_decrementCurrentWriteCounter()

def SoBase_getNamedBase(*args):
  """SoBase_getNamedBase(SbName name, SoType type) -> SoBase"""
  return _coin.SoBase_getNamedBase(*args)

def SoBase_getNamedBases(*args):
  """SoBase_getNamedBases(SbName name, SoBaseList baselist, SoType type) -> int"""
  return _coin.SoBase_getNamedBases(*args)

def SoBase_read(*args):
  """SoBase_read(SoInput input, SoBase base, SoType expectedtype) -> SbBool"""
  return _coin.SoBase_read(*args)

def SoBase_setInstancePrefix(*args):
  """SoBase_setInstancePrefix(SbString c)"""
  return _coin.SoBase_setInstancePrefix(*args)

def SoBase_setTraceRefs(*args):
  """SoBase_setTraceRefs(SbBool trace)"""
  return _coin.SoBase_setTraceRefs(*args)

def SoBase_getTraceRefs():
  """SoBase_getTraceRefs() -> SbBool"""
  return _coin.SoBase_getTraceRefs()

def SoBase_connectRoute(*args):
  """
    SoBase_connectRoute(SoInput input, SbName fromnodename, SbName fromfieldname, 
        SbName tonodename, SbName tofieldname) -> SbBool
    """
  return _coin.SoBase_connectRoute(*args)

def SoBase_readRoute(*args):
  """SoBase_readRoute(SoInput input) -> SbBool"""
  return _coin.SoBase_readRoute(*args)


def intrusive_ptr_add_ref(*args):
  """intrusive_ptr_add_ref(SoBase obj)"""
  return _coin.intrusive_ptr_add_ref(*args)

def intrusive_ptr_release(*args):
  """intrusive_ptr_release(SoBase obj)"""
  return _coin.intrusive_ptr_release(*args)
class SoBaseList(SbPList):
    """Proxy of C++ SoBaseList class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SoBaseList
        __init__(self, int size) -> SoBaseList
        __init__(self, SoBaseList l) -> SoBaseList
        """
        this = _coin.new_SoBaseList(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoBaseList
    __del__ = lambda self : None;
    def append(self, *args):
        """append(self, SoBase ptr)"""
        return _coin.SoBaseList_append(self, *args)

    def insert(self, *args):
        """insert(self, SoBase ptr, int addbefore)"""
        return _coin.SoBaseList_insert(self, *args)

    def remove(self, *args):
        """remove(self, int index)"""
        return _coin.SoBaseList_remove(self, *args)

    def removeItem(self, *args):
        """removeItem(self, SoBase item)"""
        return _coin.SoBaseList_removeItem(self, *args)

    def truncate(self, *args):
        """truncate(self, int length)"""
        return _coin.SoBaseList_truncate(self, *args)

    def copy(self, *args):
        """copy(self, SoBaseList l)"""
        return _coin.SoBaseList_copy(self, *args)

    def set(self, *args):
        """set(self, int i, SoBase ptr)"""
        return _coin.SoBaseList_set(self, *args)

    def addReferences(self, *args):
        """addReferences(self, SbBool flag)"""
        return _coin.SoBaseList_addReferences(self, *args)

    def isReferencing(self):
        """isReferencing(self) -> SbBool"""
        return _coin.SoBaseList_isReferencing(self)

    def __setitem__(self, *args):
        """__setitem__(self, int i, SoBase value)"""
        return _coin.SoBaseList___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> SoBase"""
        return _coin.SoBaseList___getitem__(self, *args)

    def get(self, *args):
        """get(self, int i) -> SoBase"""
        return _coin.SoBaseList_get(self, *args)

SoBaseList_swigregister = _coin.SoBaseList_swigregister
SoBaseList_swigregister(SoBaseList)

class SoNodeList(SoBaseList):
    """Proxy of C++ SoNodeList class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SoNodeList
        __init__(self, int size) -> SoNodeList
        __init__(self, SoNodeList nl) -> SoNodeList
        """
        this = _coin.new_SoNodeList(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoNodeList
    __del__ = lambda self : None;
    def append(self, *args):
        """append(self, SoNode ptr)"""
        return _coin.SoNodeList_append(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, SoNode value)"""
        return _coin.SoNodeList___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> SoNode"""
        return _coin.SoNodeList___getitem__(self, *args)

    def get(self, *args):
        """get(self, int i) -> SoNode"""
        return _coin.SoNodeList_get(self, *args)

SoNodeList_swigregister = _coin.SoNodeList_swigregister
SoNodeList_swigregister(SoNodeList)

class SoDetailList(SbPList):
    """Proxy of C++ SoDetailList class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SoDetailList
        __init__(self, int sizehint) -> SoDetailList
        __init__(self, SoDetailList l) -> SoDetailList
        """
        this = _coin.new_SoDetailList(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoDetailList
    __del__ = lambda self : None;
    def append(self, *args):
        """append(self, SoDetail detail)"""
        return _coin.SoDetailList_append(self, *args)

    def insert(self, *args):
        """insert(self, SoDetail detail, int insertbefore)"""
        return _coin.SoDetailList_insert(self, *args)

    def truncate(self, *args):
        """
        truncate(self, int length, int fit = 0)
        truncate(self, int length)
        """
        return _coin.SoDetailList_truncate(self, *args)

    def copy(self, *args):
        """copy(self, SoDetailList l)"""
        return _coin.SoDetailList_copy(self, *args)

    def set(self, *args):
        """set(self, int index, SoDetail item)"""
        return _coin.SoDetailList_set(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, SoDetail value)"""
        return _coin.SoDetailList___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> SoDetail"""
        return _coin.SoDetailList___getitem__(self, *args)

    def get(self, *args):
        """get(self, int i) -> SoDetail"""
        return _coin.SoDetailList_get(self, *args)

SoDetailList_swigregister = _coin.SoDetailList_swigregister
SoDetailList_swigregister(SoDetailList)

class SoTypeList(SbPList):
    """Proxy of C++ SoTypeList class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SoTypeList
        __init__(self, int sizehint) -> SoTypeList
        __init__(self, SoTypeList l) -> SoTypeList
        """
        this = _coin.new_SoTypeList(*args)
        try: self.this.append(this)
        except: self.this = this
    def append(self, *args):
        """append(self, SoType type)"""
        return _coin.SoTypeList_append(self, *args)

    def find(self, *args):
        """find(self, SoType type) -> int"""
        return _coin.SoTypeList_find(self, *args)

    def insert(self, *args):
        """insert(self, SoType type, int insertbefore)"""
        return _coin.SoTypeList_insert(self, *args)

    def set(self, *args):
        """set(self, int index, SoType item)"""
        return _coin.SoTypeList_set(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, SoType value)"""
        return _coin.SoTypeList___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> SoType"""
        return _coin.SoTypeList___getitem__(self, *args)

    def get(self, *args):
        """get(self, int i) -> SoType"""
        return _coin.SoTypeList_get(self, *args)

    __swig_destroy__ = _coin.delete_SoTypeList
    __del__ = lambda self : None;
SoTypeList_swigregister = _coin.SoTypeList_swigregister
SoTypeList_swigregister(SoTypeList)

class SoEnabledElementsList(object):
    """Proxy of C++ SoEnabledElementsList class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, SoEnabledElementsList parentlist) -> SoEnabledElementsList"""
        this = _coin.new_SoEnabledElementsList(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoEnabledElementsList
    __del__ = lambda self : None;
    def getElements(self):
        """getElements(self) -> SoTypeList"""
        return _coin.SoEnabledElementsList_getElements(self)

    def enable(self, *args):
        """enable(self, SoType elementtype, int stackindex)"""
        return _coin.SoEnabledElementsList_enable(self, *args)

    def merge(self, *args):
        """merge(self, SoEnabledElementsList eel)"""
        return _coin.SoEnabledElementsList_merge(self, *args)

    def getCounter():
        """getCounter() -> int"""
        return _coin.SoEnabledElementsList_getCounter()

    getCounter = staticmethod(getCounter)
SoEnabledElementsList_swigregister = _coin.SoEnabledElementsList_swigregister
SoEnabledElementsList_swigregister(SoEnabledElementsList)

def SoEnabledElementsList_getCounter():
  """SoEnabledElementsList_getCounter() -> int"""
  return _coin.SoEnabledElementsList_getCounter()

class SoEngineOutputList(SbPList):
    """Proxy of C++ SoEngineOutputList class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SoEngineOutputList
        __init__(self, int sizehint) -> SoEngineOutputList
        __init__(self, SoEngineOutputList l) -> SoEngineOutputList
        """
        this = _coin.new_SoEngineOutputList(*args)
        try: self.this.append(this)
        except: self.this = this
    def append(self, *args):
        """append(self, SoEngineOutput output)"""
        return _coin.SoEngineOutputList_append(self, *args)

    def insert(self, *args):
        """insert(self, SoEngineOutput output, int insertbefore)"""
        return _coin.SoEngineOutputList_insert(self, *args)

    def set(self, *args):
        """set(self, int idx, SoEngineOutput item)"""
        return _coin.SoEngineOutputList_set(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, SoEngineOutput value)"""
        return _coin.SoEngineOutputList___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> SoEngineOutput"""
        return _coin.SoEngineOutputList___getitem__(self, *args)

    def get(self, *args):
        """get(self, int i) -> SoEngineOutput"""
        return _coin.SoEngineOutputList_get(self, *args)

    __swig_destroy__ = _coin.delete_SoEngineOutputList
    __del__ = lambda self : None;
SoEngineOutputList_swigregister = _coin.SoEngineOutputList_swigregister
SoEngineOutputList_swigregister(SoEngineOutputList)

class SoEngineList(SoBaseList):
    """Proxy of C++ SoEngineList class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SoEngineList
        __init__(self, int size) -> SoEngineList
        __init__(self, SoEngineList el) -> SoEngineList
        """
        this = _coin.new_SoEngineList(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoEngineList
    __del__ = lambda self : None;
    def append(self, *args):
        """append(self, SoEngine ptr)"""
        return _coin.SoEngineList_append(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, SoEngine value)"""
        return _coin.SoEngineList___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> SoEngine"""
        return _coin.SoEngineList___getitem__(self, *args)

    def get(self, *args):
        """get(self, int i) -> SoEngine"""
        return _coin.SoEngineList_get(self, *args)

SoEngineList_swigregister = _coin.SoEngineList_swigregister
SoEngineList_swigregister(SoEngineList)

class SoFieldList(SbPList):
    """Proxy of C++ SoFieldList class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SoFieldList
        __init__(self, int sizehint) -> SoFieldList
        __init__(self, SoFieldList l) -> SoFieldList
        """
        this = _coin.new_SoFieldList(*args)
        try: self.this.append(this)
        except: self.this = this
    def append(self, *args):
        """append(self, SoField field)"""
        return _coin.SoFieldList_append(self, *args)

    def insert(self, *args):
        """insert(self, SoField field, int insertbefore)"""
        return _coin.SoFieldList_insert(self, *args)

    def set(self, *args):
        """set(self, int idx, SoField field)"""
        return _coin.SoFieldList_set(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, SoField value)"""
        return _coin.SoFieldList___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> SoField"""
        return _coin.SoFieldList___getitem__(self, *args)

    def get(self, *args):
        """
        get(self, int idx) -> SoField
        get(self, int i) -> SoField
        """
        return _coin.SoFieldList_get(self, *args)

    __swig_destroy__ = _coin.delete_SoFieldList
    __del__ = lambda self : None;
SoFieldList_swigregister = _coin.SoFieldList_swigregister
SoFieldList_swigregister(SoFieldList)

class SoPathList(SoBaseList):
    """Proxy of C++ SoPathList class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SoPathList
        __init__(self, int size) -> SoPathList
        __init__(self, SoPathList pl) -> SoPathList
        """
        this = _coin.new_SoPathList(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoPathList
    __del__ = lambda self : None;
    def append(self, *args):
        """append(self, SoPath path)"""
        return _coin.SoPathList_append(self, *args)

    def findPath(self, *args):
        """findPath(self, SoPath path) -> int"""
        return _coin.SoPathList_findPath(self, *args)

    def sort(self):
        """sort(self)"""
        return _coin.SoPathList_sort(self)

    def uniquify(self):
        """uniquify(self)"""
        return _coin.SoPathList_uniquify(self)

    def __setitem__(self, *args):
        """__setitem__(self, int i, SoPath value)"""
        return _coin.SoPathList___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> SoPath"""
        return _coin.SoPathList___getitem__(self, *args)

    def get(self, *args):
        """get(self, int i) -> SoPath"""
        return _coin.SoPathList_get(self, *args)

SoPathList_swigregister = _coin.SoPathList_swigregister
SoPathList_swigregister(SoPathList)

class SoPickedPointList(SbPList):
    """Proxy of C++ SoPickedPointList class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SoPickedPointList
        __init__(self, int sizehint) -> SoPickedPointList
        __init__(self, SoPickedPointList l) -> SoPickedPointList
        """
        this = _coin.new_SoPickedPointList(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoPickedPointList
    __del__ = lambda self : None;
    def append(self, *args):
        """append(self, SoPickedPoint pp)"""
        return _coin.SoPickedPointList_append(self, *args)

    def insert(self, *args):
        """insert(self, SoPickedPoint pp, int insertbefore)"""
        return _coin.SoPickedPointList_insert(self, *args)

    def truncate(self, *args):
        """
        truncate(self, int start, int fit = 0)
        truncate(self, int start)
        """
        return _coin.SoPickedPointList_truncate(self, *args)

    def set(self, *args):
        """set(self, int idx, SoPickedPoint pp)"""
        return _coin.SoPickedPointList_set(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, SoPickedPoint value)"""
        return _coin.SoPickedPointList___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> SoPickedPoint"""
        return _coin.SoPickedPointList___getitem__(self, *args)

    def get(self, *args):
        """get(self, int i) -> SoPickedPoint"""
        return _coin.SoPickedPointList_get(self, *args)

SoPickedPointList_swigregister = _coin.SoPickedPointList_swigregister
SoPickedPointList_swigregister(SoPickedPointList)

class SoPath(SoBase):
    """Proxy of C++ SoPath class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def initClass():
        """initClass()"""
        return _coin.SoPath_initClass()

    initClass = staticmethod(initClass)
    def __init__(self, *args): 
        """
        __init__(self, int approxlength = 4) -> SoPath
        __init__(self) -> SoPath
        __init__(self, SoNode head) -> SoPath
        __init__(self, SoPath rhs) -> SoPath
        """
        this = _coin.new_SoPath(*args)
        try: self.this.append(this)
        except: self.this = this
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoPath_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoPath_getTypeId(self)

    def setHead(self, *args):
        """setHead(self, SoNode head)"""
        return _coin.SoPath_setHead(self, *args)

    def getHead(self):
        """getHead(self) -> SoNode"""
        return _coin.SoPath_getHead(self)

    def append(self, *args):
        """
        append(self, int childindex)
        append(self, SoNode node)
        append(self, SoPath frompath)
        """
        return _coin.SoPath_append(self, *args)

    def push(self, *args):
        """push(self, int childindex)"""
        return _coin.SoPath_push(self, *args)

    def pop(self):
        """pop(self)"""
        return _coin.SoPath_pop(self)

    def getTail(self):
        """getTail(self) -> SoNode"""
        return _coin.SoPath_getTail(self)

    def getNode(self, *args):
        """getNode(self, int index) -> SoNode"""
        return _coin.SoPath_getNode(self, *args)

    def getNodeFromTail(self, *args):
        """getNodeFromTail(self, int index) -> SoNode"""
        return _coin.SoPath_getNodeFromTail(self, *args)

    def getIndex(self, *args):
        """getIndex(self, int index) -> int"""
        return _coin.SoPath_getIndex(self, *args)

    def getIndexFromTail(self, *args):
        """getIndexFromTail(self, int index) -> int"""
        return _coin.SoPath_getIndexFromTail(self, *args)

    def getLength(self):
        """getLength(self) -> int"""
        return _coin.SoPath_getLength(self)

    def truncate(self, *args):
        """truncate(self, int length)"""
        return _coin.SoPath_truncate(self, *args)

    def findFork(self, *args):
        """findFork(self, SoPath path) -> int"""
        return _coin.SoPath_findFork(self, *args)

    def findNode(self, *args):
        """findNode(self, SoNode node) -> int"""
        return _coin.SoPath_findNode(self, *args)

    def containsNode(self, *args):
        """containsNode(self, SoNode node) -> SbBool"""
        return _coin.SoPath_containsNode(self, *args)

    def containsPath(self, *args):
        """containsPath(self, SoPath path) -> SbBool"""
        return _coin.SoPath_containsPath(self, *args)

    def copy(self, startfromnodeindex = 0, numnodes = 0):
        """
        copy(self, int startfromnodeindex = 0, int numnodes = 0) -> SoPath
        copy(self, int startfromnodeindex = 0) -> SoPath
        copy(self) -> SoPath
        """
        return _coin.SoPath_copy(self, startfromnodeindex, numnodes)

    def getByName(*args):
        """
        getByName(SbName name) -> SoPath
        getByName(SbName name, SoPathList l) -> int
        """
        return _coin.SoPath_getByName(*args)

    getByName = staticmethod(getByName)
    def insertIndex(self, *args):
        """insertIndex(self, SoNode parent, int newindex)"""
        return _coin.SoPath_insertIndex(self, *args)

    def removeIndex(self, *args):
        """removeIndex(self, SoNode parent, int oldindex)"""
        return _coin.SoPath_removeIndex(self, *args)

    def replaceIndex(self, *args):
        """replaceIndex(self, SoNode parent, int index, SoNode newchild)"""
        return _coin.SoPath_replaceIndex(self, *args)

    def isRelevantNotification(self, *args):
        """isRelevantNotification(self, SoNotList l) -> SbBool"""
        return _coin.SoPath_isRelevantNotification(self, *args)

    def write(self, *args):
        """write(self, SoWriteAction action)"""
        return _coin.SoPath_write(self, *args)

    def __iter__(self):
       for i in range(self.getLength()):
          yield self.getNode(i)

    def index(self):
       for i in range(self.getLength()):
          yield self.getIndex(i)

    def __eq__(self, *args):
        """__eq__(self, SoPath u) -> int"""
        return _coin.SoPath___eq__(self, *args)

    def __nq__(self, *args):
        """__nq__(self, SoPath u) -> int"""
        return _coin.SoPath___nq__(self, *args)

SoPath_swigregister = _coin.SoPath_swigregister
SoPath_swigregister(SoPath)

def SoPath_initClass():
  """SoPath_initClass()"""
  return _coin.SoPath_initClass()

def SoPath_getClassTypeId():
  """SoPath_getClassTypeId() -> SoType"""
  return _coin.SoPath_getClassTypeId()

def SoPath_getByName(*args):
  """
    getByName(SbName name) -> SoPath
    SoPath_getByName(SbName name, SoPathList l) -> int
    """
  return _coin.SoPath_getByName(*args)

class SoLightPath(object):
    """Proxy of C++ SoLightPath class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, SoNode node, int approxlength) -> SoLightPath
        __init__(self, int approxlength) -> SoLightPath
        """
        this = _coin.new_SoLightPath(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoLightPath
    __del__ = lambda self : None;
    def setHead(self, *args):
        """setHead(self, SoNode node)"""
        return _coin.SoLightPath_setHead(self, *args)

    def append(self, *args):
        """append(self, int childindex)"""
        return _coin.SoLightPath_append(self, *args)

    def push(self, *args):
        """push(self, int childindex)"""
        return _coin.SoLightPath_push(self, *args)

    def pop(self):
        """pop(self)"""
        return _coin.SoLightPath_pop(self)

    def setTail(self, *args):
        """setTail(self, int childindex)"""
        return _coin.SoLightPath_setTail(self, *args)

    def getTail(self):
        """getTail(self) -> SoNode"""
        return _coin.SoLightPath_getTail(self)

    def getHead(self):
        """getHead(self) -> SoNode"""
        return _coin.SoLightPath_getHead(self)

    def getNode(self, *args):
        """getNode(self, int index) -> SoNode"""
        return _coin.SoLightPath_getNode(self, *args)

    def getIndex(self, *args):
        """getIndex(self, int index) -> int"""
        return _coin.SoLightPath_getIndex(self, *args)

    def getFullLength(self):
        """getFullLength(self) -> int"""
        return _coin.SoLightPath_getFullLength(self)

    def truncate(self, *args):
        """truncate(self, int startindex)"""
        return _coin.SoLightPath_truncate(self, *args)

    def makeTempPath(self, *args):
        """makeTempPath(self, SoTempPath path)"""
        return _coin.SoLightPath_makeTempPath(self, *args)

SoLightPath_swigregister = _coin.SoLightPath_swigregister
SoLightPath_swigregister(SoLightPath)

class SoFullPath(SoPath):
    """Proxy of C++ SoFullPath class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def pop(self):
        """pop(self)"""
        return _coin.SoFullPath_pop(self)

    def getTail(self):
        """getTail(self) -> SoNode"""
        return _coin.SoFullPath_getTail(self)

    def getNodeFromTail(self, *args):
        """getNodeFromTail(self, int index) -> SoNode"""
        return _coin.SoFullPath_getNodeFromTail(self, *args)

    def getIndexFromTail(self, *args):
        """getIndexFromTail(self, int index) -> int"""
        return _coin.SoFullPath_getIndexFromTail(self, *args)

    def getLength(self):
        """getLength(self) -> int"""
        return _coin.SoFullPath_getLength(self)

    def fromSoPath(*args):
        """fromSoPath(SoPath path) -> SoFullPath"""
        return _coin.SoFullPath_fromSoPath(*args)

    fromSoPath = staticmethod(fromSoPath)
SoFullPath_swigregister = _coin.SoFullPath_swigregister
SoFullPath_swigregister(SoFullPath)

def SoFullPath_fromSoPath(*args):
  """SoFullPath_fromSoPath(SoPath path) -> SoFullPath"""
  return _coin.SoFullPath_fromSoPath(*args)

class SoTempPath(SoFullPath):
    """Proxy of C++ SoTempPath class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, int approxlength) -> SoTempPath"""
        this = _coin.new_SoTempPath(*args)
        try: self.this.append(this)
        except: self.this = this
    def simpleAppend(self, *args):
        """simpleAppend(self, SoNode node, int index)"""
        return _coin.SoTempPath_simpleAppend(self, *args)

    def replaceTail(self, *args):
        """replaceTail(self, SoNode node, int index)"""
        return _coin.SoTempPath_replaceTail(self, *args)

SoTempPath_swigregister = _coin.SoTempPath_swigregister
SoTempPath_swigregister(SoTempPath)

class SoActionMethodList(SbPList):
    """Proxy of C++ SoActionMethodList class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, SoActionMethodList parentlist) -> SoActionMethodList"""
        this = _coin.new_SoActionMethodList(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoActionMethodList
    __del__ = lambda self : None;
    def addMethod(self, *args):
        """addMethod(self, SoType node, SoActionMethod method)"""
        return _coin.SoActionMethodList_addMethod(self, *args)

    def setUp(self):
        """setUp(self)"""
        return _coin.SoActionMethodList_setUp(self)

    def __setitem__(self, *args):
        """__setitem__(self, int i, SoActionMethod value)"""
        return _coin.SoActionMethodList___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> SoActionMethod"""
        return _coin.SoActionMethodList___getitem__(self, *args)

    def get(self, *args):
        """get(self, int i) -> SoActionMethod"""
        return _coin.SoActionMethodList_get(self, *args)

SoActionMethodList_swigregister = _coin.SoActionMethodList_swigregister
SoActionMethodList_swigregister(SoActionMethodList)

class SoAction(object):
    """Proxy of C++ SoAction class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def initClass():
        """initClass()"""
        return _coin.SoAction_initClass()

    initClass = staticmethod(initClass)
    def initClasses():
        """initClasses()"""
        return _coin.SoAction_initClasses()

    initClasses = staticmethod(initClasses)
    NODE = _coin.SoAction_NODE
    PATH = _coin.SoAction_PATH
    PATH_LIST = _coin.SoAction_PATH_LIST
    NO_PATH = _coin.SoAction_NO_PATH
    IN_PATH = _coin.SoAction_IN_PATH
    BELOW_PATH = _coin.SoAction_BELOW_PATH
    OFF_PATH = _coin.SoAction_OFF_PATH
    __swig_destroy__ = _coin.delete_SoAction
    __del__ = lambda self : None;
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoAction_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoAction_getTypeId(self)

    def isOfType(self, *args):
        """isOfType(self, SoType type) -> SbBool"""
        return _coin.SoAction_isOfType(self, *args)

    def apply(self, *args):
        """
        apply(self, SoNode root)
        apply(self, SoPath path)
        apply(self, SoPathList pathlist, SbBool obeysrules = 0)
        apply(self, SoPathList pathlist)
        apply(self, SoAction beingApplied)
        """
        return _coin.SoAction_apply(self, *args)

    def invalidateState(self):
        """invalidateState(self)"""
        return _coin.SoAction_invalidateState(self)

    def nullAction(*args):
        """nullAction(SoAction action, SoNode node)"""
        return _coin.SoAction_nullAction(*args)

    nullAction = staticmethod(nullAction)
    def getWhatAppliedTo(self):
        """getWhatAppliedTo(self) -> AppliedCode"""
        return _coin.SoAction_getWhatAppliedTo(self)

    def getNodeAppliedTo(self):
        """getNodeAppliedTo(self) -> SoNode"""
        return _coin.SoAction_getNodeAppliedTo(self)

    def getPathAppliedTo(self):
        """getPathAppliedTo(self) -> SoPath"""
        return _coin.SoAction_getPathAppliedTo(self)

    def getPathListAppliedTo(self):
        """getPathListAppliedTo(self) -> SoPathList"""
        return _coin.SoAction_getPathListAppliedTo(self)

    def getOriginalPathListAppliedTo(self):
        """getOriginalPathListAppliedTo(self) -> SoPathList"""
        return _coin.SoAction_getOriginalPathListAppliedTo(self)

    def isLastPathListAppliedTo(self):
        """isLastPathListAppliedTo(self) -> SbBool"""
        return _coin.SoAction_isLastPathListAppliedTo(self)

    def getPathCode(self, *args):
        """getPathCode(self, int numindices, int indices) -> PathCode"""
        return _coin.SoAction_getPathCode(self, *args)

    def traverse(self, *args):
        """traverse(self, SoNode node)"""
        return _coin.SoAction_traverse(self, *args)

    def hasTerminated(self):
        """hasTerminated(self) -> SbBool"""
        return _coin.SoAction_hasTerminated(self)

    def getCurPath(self):
        """getCurPath(self) -> SoPath"""
        return _coin.SoAction_getCurPath(self)

    def getState(self):
        """getState(self) -> SoState"""
        return _coin.SoAction_getState(self)

    def getCurPathCode(self):
        """getCurPathCode(self) -> PathCode"""
        return _coin.SoAction_getCurPathCode(self)

    def getCurPathTail(self):
        """getCurPathTail(self) -> SoNode"""
        return _coin.SoAction_getCurPathTail(self)

    def usePathCode(self, *args):
        """usePathCode(self, int numindices, int indices)"""
        return _coin.SoAction_usePathCode(self, *args)

    def pushCurPath(self, *args):
        """
        pushCurPath(self, int childindex, SoNode node = None)
        pushCurPath(self, int childindex)
        pushCurPath(self)
        """
        return _coin.SoAction_pushCurPath(self, *args)

    def popPushCurPath(self, *args):
        """
        popPushCurPath(self, int childindex, SoNode node = None)
        popPushCurPath(self, int childindex)
        """
        return _coin.SoAction_popPushCurPath(self, *args)

    def popCurPath(self, *args):
        """
        popCurPath(self, PathCode prevpathcode)
        popCurPath(self)
        """
        return _coin.SoAction_popCurPath(self, *args)

    def switchToPathTraversal(self, *args):
        """switchToPathTraversal(self, SoPath path)"""
        return _coin.SoAction_switchToPathTraversal(self, *args)

    def switchToNodeTraversal(self, *args):
        """switchToNodeTraversal(self, SoNode node)"""
        return _coin.SoAction_switchToNodeTraversal(self, *args)

SoAction_swigregister = _coin.SoAction_swigregister
SoAction_swigregister(SoAction)

def SoAction_initClass():
  """SoAction_initClass()"""
  return _coin.SoAction_initClass()

def SoAction_initClasses():
  """SoAction_initClasses()"""
  return _coin.SoAction_initClasses()

def SoAction_getClassTypeId():
  """SoAction_getClassTypeId() -> SoType"""
  return _coin.SoAction_getClassTypeId()

def SoAction_nullAction(*args):
  """SoAction_nullAction(SoAction action, SoNode node)"""
  return _coin.SoAction_nullAction(*args)

class SoState(object):
    """Proxy of C++ SoState class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, SoAction action, SoTypeList enabledelements) -> SoState"""
        this = _coin.new_SoState(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoState
    __del__ = lambda self : None;
    def getAction(self):
        """getAction(self) -> SoAction"""
        return _coin.SoState_getAction(self)

    def getElement(self, *args):
        """getElement(self, int stackindex) -> SoElement"""
        return _coin.SoState_getElement(self, *args)

    def getConstElement(self, *args):
        """getConstElement(self, int stackindex) -> SoElement"""
        return _coin.SoState_getConstElement(self, *args)

    def push(self):
        """push(self)"""
        return _coin.SoState_push(self)

    def pop(self):
        """pop(self)"""
        return _coin.SoState_pop(self)

    def output(self, *args):
        """
        output(self, FILE file = stdout)
        output(self)
        """
        return _coin.SoState_output(self, *args)

    def isElementEnabled(self, *args):
        """isElementEnabled(self, int stackindex) -> SbBool"""
        return _coin.SoState_isElementEnabled(self, *args)

    def getDepth(self):
        """getDepth(self) -> int"""
        return _coin.SoState_getDepth(self)

    def setCacheOpen(self, *args):
        """setCacheOpen(self, SbBool flag)"""
        return _coin.SoState_setCacheOpen(self, *args)

    def isCacheOpen(self):
        """isCacheOpen(self) -> SbBool"""
        return _coin.SoState_isCacheOpen(self)

    def getElementNoPush(self, *args):
        """getElementNoPush(self, int stackindex) -> SoElement"""
        return _coin.SoState_getElementNoPush(self, *args)

SoState_swigregister = _coin.SoState_swigregister
SoState_swigregister(SoState)

class SoElement(object):
    """Proxy of C++ SoElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def initClass():
        """initClass()"""
        return _coin.SoElement_initClass()

    initClass = staticmethod(initClass)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoElement_getTypeId(self)

    def getStackIndex(self):
        """getStackIndex(self) -> int"""
        return _coin.SoElement_getStackIndex(self)

    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoElement_pop(self, *args)

    def matches(self, *args):
        """matches(self, SoElement element) -> SbBool"""
        return _coin.SoElement_matches(self, *args)

    def copyMatchInfo(self):
        """copyMatchInfo(self) -> SoElement"""
        return _coin.SoElement_copyMatchInfo(self)

    def initElements():
        """initElements()"""
        return _coin.SoElement_initElements()

    initElements = staticmethod(initElements)
    def getNumStackIndices():
        """getNumStackIndices() -> int"""
        return _coin.SoElement_getNumStackIndices()

    getNumStackIndices = staticmethod(getNumStackIndices)
    def getIdFromStackIndex(*args):
        """getIdFromStackIndex(int stackIndex) -> SoType"""
        return _coin.SoElement_getIdFromStackIndex(*args)

    getIdFromStackIndex = staticmethod(getIdFromStackIndex)
    def setDepth(self, *args):
        """setDepth(self, int depth)"""
        return _coin.SoElement_setDepth(self, *args)

    def getDepth(self):
        """getDepth(self) -> int"""
        return _coin.SoElement_getDepth(self)

    def output(self, *args):
        """
        output(self, FILE file = stdout)
        output(self)
        """
        return _coin.SoElement_output(self, *args)

    __swig_destroy__ = _coin.delete_SoElement
    __del__ = lambda self : None;
SoElement_swigregister = _coin.SoElement_swigregister
SoElement_swigregister(SoElement)

def SoElement_initClass():
  """SoElement_initClass()"""
  return _coin.SoElement_initClass()

def SoElement_getClassTypeId():
  """SoElement_getClassTypeId() -> SoType"""
  return _coin.SoElement_getClassTypeId()

def SoElement_getClassStackIndex():
  """SoElement_getClassStackIndex() -> int"""
  return _coin.SoElement_getClassStackIndex()

def SoElement_initElements():
  """SoElement_initElements()"""
  return _coin.SoElement_initElements()

def SoElement_getNumStackIndices():
  """SoElement_getNumStackIndices() -> int"""
  return _coin.SoElement_getNumStackIndices()

def SoElement_getIdFromStackIndex(*args):
  """SoElement_getIdFromStackIndex(int stackIndex) -> SoType"""
  return _coin.SoElement_getIdFromStackIndex(*args)

class SoInt32Element(SoElement):
    """Proxy of C++ SoInt32Element class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoInt32Element_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoInt32Element_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def initClass():
        """initClass()"""
        return _coin.SoInt32Element_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoInt32Element_init(self, *args)

    def matches(self, *args):
        """matches(self, SoElement element) -> SbBool"""
        return _coin.SoInt32Element_matches(self, *args)

    def copyMatchInfo(self):
        """copyMatchInfo(self) -> SoElement"""
        return _coin.SoInt32Element_copyMatchInfo(self)

    def output(self, *args):
        """output(self, FILE file)"""
        return _coin.SoInt32Element_output(self, *args)

    def set(*args):
        """
        set(int index, SoState state, SoNode node, int32_t value)
        set(int index, SoState state, int32_t value)
        """
        return _coin.SoInt32Element_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(int index, SoState state) -> int32_t"""
        return _coin.SoInt32Element_get(*args)

    get = staticmethod(get)
    def setElt(self, *args):
        """setElt(self, int32_t value)"""
        return _coin.SoInt32Element_setElt(self, *args)

SoInt32Element_swigregister = _coin.SoInt32Element_swigregister
SoInt32Element_swigregister(SoInt32Element)

def SoInt32Element_getClassTypeId():
  """SoInt32Element_getClassTypeId() -> SoType"""
  return _coin.SoInt32Element_getClassTypeId()

def SoInt32Element_getClassStackIndex():
  """SoInt32Element_getClassStackIndex() -> int"""
  return _coin.SoInt32Element_getClassStackIndex()

def SoInt32Element_initClass():
  """SoInt32Element_initClass()"""
  return _coin.SoInt32Element_initClass()

def SoInt32Element_set(*args):
  """
    set(int index, SoState state, SoNode node, int32_t value)
    SoInt32Element_set(int index, SoState state, int32_t value)
    """
  return _coin.SoInt32Element_set(*args)

def SoInt32Element_get(*args):
  """SoInt32Element_get(int index, SoState state) -> int32_t"""
  return _coin.SoInt32Element_get(*args)

class SoDecimationTypeElement(SoInt32Element):
    """Proxy of C++ SoDecimationTypeElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoDecimationTypeElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoDecimationTypeElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoDecimationTypeElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoDecimationTypeElement_initClass()

    initClass = staticmethod(initClass)
    AUTOMATIC = _coin.SoDecimationTypeElement_AUTOMATIC
    HIGHEST = _coin.SoDecimationTypeElement_HIGHEST
    LOWEST = _coin.SoDecimationTypeElement_LOWEST
    PERCENTAGE = _coin.SoDecimationTypeElement_PERCENTAGE
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoDecimationTypeElement_init(self, *args)

    def set(*args):
        """
        set(SoState state, Type type)
        set(SoState state, SoNode node, Type type)
        """
        return _coin.SoDecimationTypeElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> Type"""
        return _coin.SoDecimationTypeElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> Type"""
        return _coin.SoDecimationTypeElement_getDefault()

    getDefault = staticmethod(getDefault)
SoDecimationTypeElement_swigregister = _coin.SoDecimationTypeElement_swigregister
SoDecimationTypeElement_swigregister(SoDecimationTypeElement)

def SoDecimationTypeElement_getClassTypeId():
  """SoDecimationTypeElement_getClassTypeId() -> SoType"""
  return _coin.SoDecimationTypeElement_getClassTypeId()

def SoDecimationTypeElement_getClassStackIndex():
  """SoDecimationTypeElement_getClassStackIndex() -> int"""
  return _coin.SoDecimationTypeElement_getClassStackIndex()

def SoDecimationTypeElement_createInstance():
  """SoDecimationTypeElement_createInstance() -> void"""
  return _coin.SoDecimationTypeElement_createInstance()

def SoDecimationTypeElement_initClass():
  """SoDecimationTypeElement_initClass()"""
  return _coin.SoDecimationTypeElement_initClass()

def SoDecimationTypeElement_set(*args):
  """
    set(SoState state, Type type)
    SoDecimationTypeElement_set(SoState state, SoNode node, Type type)
    """
  return _coin.SoDecimationTypeElement_set(*args)

def SoDecimationTypeElement_get(*args):
  """SoDecimationTypeElement_get(SoState state) -> Type"""
  return _coin.SoDecimationTypeElement_get(*args)

def SoDecimationTypeElement_getDefault():
  """SoDecimationTypeElement_getDefault() -> Type"""
  return _coin.SoDecimationTypeElement_getDefault()

class SoFieldData(object):
    """Proxy of C++ SoFieldData class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SoFieldData
        __init__(self, SoFieldData fd) -> SoFieldData
        __init__(self, SoFieldData fd) -> SoFieldData
        __init__(self, int numfields) -> SoFieldData
        """
        this = _coin.new_SoFieldData(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoFieldData
    __del__ = lambda self : None;
    def addField(self, *args):
        """addField(self, SoFieldContainer base, char name, SoField field)"""
        return _coin.SoFieldData_addField(self, *args)

    def overlay(self, *args):
        """
        overlay(self, SoFieldContainer destTo, SoFieldContainer srcFrom, 
            SbBool copyconnections)
        """
        return _coin.SoFieldData_overlay(self, *args)

    def getNumFields(self):
        """getNumFields(self) -> int"""
        return _coin.SoFieldData_getNumFields(self)

    def getFieldName(self, *args):
        """getFieldName(self, int index) -> SbName"""
        return _coin.SoFieldData_getFieldName(self, *args)

    def getField(self, *args):
        """getField(self, SoFieldContainer object, int index) -> SoField"""
        return _coin.SoFieldData_getField(self, *args)

    def getIndex(self, *args):
        """getIndex(self, SoFieldContainer fc, SoField field) -> int"""
        return _coin.SoFieldData_getIndex(self, *args)

    def addEnumValue(self, *args):
        """addEnumValue(self, char enumname, char valuename, int value)"""
        return _coin.SoFieldData_addEnumValue(self, *args)

    def getEnumData(self, *args):
        """getEnumData(self, char enumname, int num, int values, SbName names)"""
        return _coin.SoFieldData_getEnumData(self, *args)

    def read(self, *args):
        """
        read(self, SoInput input, SoFieldContainer object, SbBool erroronunknownfield, 
            SbBool notbuiltin) -> SbBool
        read(self, SoInput input, SoFieldContainer object, SbName fieldname, 
            SbBool foundname) -> SbBool
        """
        return _coin.SoFieldData_read(self, *args)

    def write(self, *args):
        """write(self, SoOutput out, SoFieldContainer object)"""
        return _coin.SoFieldData_write(self, *args)

    def copy(self, *args):
        """copy(self, SoFieldData src)"""
        return _coin.SoFieldData_copy(self, *args)

    def isSame(self, *args):
        """isSame(self, SoFieldContainer c1, SoFieldContainer c2) -> SbBool"""
        return _coin.SoFieldData_isSame(self, *args)

    def readFieldDescriptions(self, *args):
        """
        readFieldDescriptions(self, SoInput input, SoFieldContainer object, int numdescriptionsexpected, 
            SbBool readfieldvalues = 1) -> SbBool
        readFieldDescriptions(self, SoInput input, SoFieldContainer object, int numdescriptionsexpected) -> SbBool
        """
        return _coin.SoFieldData_readFieldDescriptions(self, *args)

    def writeFieldDescriptions(self, *args):
        """writeFieldDescriptions(self, SoOutput out, SoFieldContainer object)"""
        return _coin.SoFieldData_writeFieldDescriptions(self, *args)

SoFieldData_swigregister = _coin.SoFieldData_swigregister
SoFieldData_swigregister(SoFieldData)

class SoFieldContainer(SoBase):
    """Proxy of C++ SoFieldContainer class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def initClass():
        """initClass()"""
        return _coin.SoFieldContainer_initClass()

    initClass = staticmethod(initClass)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoFieldContainer_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def cleanupClass():
        """cleanupClass()"""
        return _coin.SoFieldContainer_cleanupClass()

    cleanupClass = staticmethod(cleanupClass)
    def setToDefaults(self):
        """setToDefaults(self)"""
        return _coin.SoFieldContainer_setToDefaults(self)

    def hasDefaultValues(self):
        """hasDefaultValues(self) -> SbBool"""
        return _coin.SoFieldContainer_hasDefaultValues(self)

    def fieldsAreEqual(self, *args):
        """fieldsAreEqual(self, SoFieldContainer container) -> SbBool"""
        return _coin.SoFieldContainer_fieldsAreEqual(self, *args)

    def copyFieldValues(self, *args):
        """
        copyFieldValues(self, SoFieldContainer container, SbBool copyconnections = 0)
        copyFieldValues(self, SoFieldContainer container)
        """
        return _coin.SoFieldContainer_copyFieldValues(self, *args)

    def getFields(self, *args):
        """getFields(self, SoFieldList l) -> int"""
        return _coin.SoFieldContainer_getFields(self, *args)

    def getAllFields(self, *args):
        """getAllFields(self, SoFieldList l) -> int"""
        return _coin.SoFieldContainer_getAllFields(self, *args)

    def getField(self, *args):
        """getField(self, SbName name) -> SoField"""
        return _coin.SoFieldContainer_getField(self, *args)

    def getEventIn(self, *args):
        """getEventIn(self, SbName name) -> SoField"""
        return _coin.SoFieldContainer_getEventIn(self, *args)

    def getEventOut(self, *args):
        """getEventOut(self, SbName name) -> SoField"""
        return _coin.SoFieldContainer_getEventOut(self, *args)

    def enableNotify(self, *args):
        """enableNotify(self, SbBool flag) -> SbBool"""
        return _coin.SoFieldContainer_enableNotify(self, *args)

    def isNotifyEnabled(self):
        """isNotifyEnabled(self) -> SbBool"""
        return _coin.SoFieldContainer_isNotifyEnabled(self)

    def set(self, *args):
        """
        set(self, char fielddata) -> SbBool
        set(self, char fielddata, SoInput input) -> SbBool
        """
        return _coin.SoFieldContainer_set(self, *args)

    def get(self, *args):
        """
        get(self, SbString fielddata)
        get(self, SbString fielddata, SoOutput out)
        """
        return _coin.SoFieldContainer_get(self, *args)

    def notify(self, *args):
        """notify(self, SoNotList l)"""
        return _coin.SoFieldContainer_notify(self, *args)

    def validateNewFieldValue(self, *args):
        """validateNewFieldValue(self, SoField field, void newval) -> SbBool"""
        return _coin.SoFieldContainer_validateNewFieldValue(self, *args)

    def addWriteReference(self, *args):
        """
        addWriteReference(self, SoOutput out, SbBool isfromfield = 0)
        addWriteReference(self, SoOutput out)
        """
        return _coin.SoFieldContainer_addWriteReference(self, *args)

    def writeInstance(self, *args):
        """writeInstance(self, SoOutput out)"""
        return _coin.SoFieldContainer_writeInstance(self, *args)

    def getIsBuiltIn(self):
        """getIsBuiltIn(self) -> SbBool"""
        return _coin.SoFieldContainer_getIsBuiltIn(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoFieldContainer_getFieldData(self)

    def copyContents(self, *args):
        """copyContents(self, SoFieldContainer srcFrom, SbBool copyconnections)"""
        return _coin.SoFieldContainer_copyContents(self, *args)

    def copyThroughConnection(self):
        """copyThroughConnection(self) -> SoFieldContainer"""
        return _coin.SoFieldContainer_copyThroughConnection(self)

    def initCopyDict():
        """initCopyDict()"""
        return _coin.SoFieldContainer_initCopyDict()

    initCopyDict = staticmethod(initCopyDict)
    def addCopy(*args):
        """addCopy(SoFieldContainer orig, SoFieldContainer copy)"""
        return _coin.SoFieldContainer_addCopy(*args)

    addCopy = staticmethod(addCopy)
    def checkCopy(*args):
        """checkCopy(SoFieldContainer orig) -> SoFieldContainer"""
        return _coin.SoFieldContainer_checkCopy(*args)

    checkCopy = staticmethod(checkCopy)
    def findCopy(*args):
        """findCopy(SoFieldContainer orig, SbBool copyconnections) -> SoFieldContainer"""
        return _coin.SoFieldContainer_findCopy(*args)

    findCopy = staticmethod(findCopy)
    def copyDone():
        """copyDone()"""
        return _coin.SoFieldContainer_copyDone()

    copyDone = staticmethod(copyDone)
    def getFieldsMemorySize(self, *args):
        """getFieldsMemorySize(self, size_t managed, size_t unmanaged)"""
        return _coin.SoFieldContainer_getFieldsMemorySize(self, *args)

    def setUserData(self, *args):
        """setUserData(self, void userdata)"""
        return _coin.SoFieldContainer_setUserData(self, *args)

    def getUserData(self):
        """getUserData(self) -> void"""
        return _coin.SoFieldContainer_getUserData(self)

    def getFieldName(self, *args):
        """
        getFieldName(self, SoField field, SbName name) -> SbBool
        getFieldName(self, SoField field) -> PyObject
        """
        return _coin.SoFieldContainer_getFieldName(self, *args)

    def __getattr__(self, name):
      try:
          return SoBase.__getattribute__(self, name)
      except AttributeError, e:
          field = self.getField(name)
          if field is None:
              raise e
          return field
            
    def __setattr__(self, name, value):
      # I don't understand why we need this, but otherwise it does not work :/
      if name == 'this':
          return SoBase.__setattr__(self, name, value)
      field = self.getField(name)
      if field is None:
          return SoBase.__setattr__(self, name, value)
      field.setValue(value)
      return field

SoFieldContainer_swigregister = _coin.SoFieldContainer_swigregister
SoFieldContainer_swigregister(SoFieldContainer)

def SoFieldContainer_initClass():
  """SoFieldContainer_initClass()"""
  return _coin.SoFieldContainer_initClass()

def SoFieldContainer_getClassTypeId():
  """SoFieldContainer_getClassTypeId() -> SoType"""
  return _coin.SoFieldContainer_getClassTypeId()

def SoFieldContainer_cleanupClass():
  """SoFieldContainer_cleanupClass()"""
  return _coin.SoFieldContainer_cleanupClass()

def SoFieldContainer_initCopyDict():
  """SoFieldContainer_initCopyDict()"""
  return _coin.SoFieldContainer_initCopyDict()

def SoFieldContainer_addCopy(*args):
  """SoFieldContainer_addCopy(SoFieldContainer orig, SoFieldContainer copy)"""
  return _coin.SoFieldContainer_addCopy(*args)

def SoFieldContainer_checkCopy(*args):
  """SoFieldContainer_checkCopy(SoFieldContainer orig) -> SoFieldContainer"""
  return _coin.SoFieldContainer_checkCopy(*args)

def SoFieldContainer_findCopy(*args):
  """SoFieldContainer_findCopy(SoFieldContainer orig, SbBool copyconnections) -> SoFieldContainer"""
  return _coin.SoFieldContainer_findCopy(*args)

def SoFieldContainer_copyDone():
  """SoFieldContainer_copyDone()"""
  return _coin.SoFieldContainer_copyDone()

class SoNode(SoFieldContainer):
    """Proxy of C++ SoNode class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    FIRST_INSTANCE = _coin.SoNode_FIRST_INSTANCE
    PROTO_INSTANCE = _coin.SoNode_PROTO_INSTANCE
    OTHER_INSTANCE = _coin.SoNode_OTHER_INSTANCE
    def setOverride(self, *args):
        """setOverride(self, SbBool state)"""
        return _coin.SoNode_setOverride(self, *args)

    def isOverride(self):
        """isOverride(self) -> SbBool"""
        return _coin.SoNode_isOverride(self)

    INVENTOR = _coin.SoNode_INVENTOR
    VRML1 = _coin.SoNode_VRML1
    VRML2 = _coin.SoNode_VRML2
    INVENTOR_1 = _coin.SoNode_INVENTOR_1
    INVENTOR_2_0 = _coin.SoNode_INVENTOR_2_0
    INVENTOR_2_1 = _coin.SoNode_INVENTOR_2_1
    INVENTOR_2_5 = _coin.SoNode_INVENTOR_2_5
    INVENTOR_2_6 = _coin.SoNode_INVENTOR_2_6
    COIN_1_0 = _coin.SoNode_COIN_1_0
    COIN_2_0 = _coin.SoNode_COIN_2_0
    EXTENSION = _coin.SoNode_EXTENSION
    COIN_2_2 = _coin.SoNode_COIN_2_2
    COIN_2_3 = _coin.SoNode_COIN_2_3
    COIN_2_4 = _coin.SoNode_COIN_2_4
    INVENTOR_5_0 = _coin.SoNode_INVENTOR_5_0
    COIN_2_5 = _coin.SoNode_COIN_2_5
    COIN_3_0 = _coin.SoNode_COIN_3_0
    INVENTOR_6_0 = _coin.SoNode_INVENTOR_6_0
    def getCompatibilityTypes(*args):
        """getCompatibilityTypes(SoType nodetype) -> uint32_t"""
        return _coin.SoNode_getCompatibilityTypes(*args)

    getCompatibilityTypes = staticmethod(getCompatibilityTypes)
    def setNodeType(self, *args):
        """setNodeType(self, NodeType type)"""
        return _coin.SoNode_setNodeType(self, *args)

    def getNodeType(self):
        """getNodeType(self) -> NodeType"""
        return _coin.SoNode_getNodeType(self)

    def copy(self, copyconnections = 0):
        """
        copy(self, SbBool copyconnections = 0) -> SoNode
        copy(self) -> SoNode
        """
        return _coin.SoNode_copy(self, copyconnections)

    def affectsState(self):
        """affectsState(self) -> SbBool"""
        return _coin.SoNode_affectsState(self)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoNode_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoNode_GLRender(self, *args)

    def GLRenderBelowPath(self, *args):
        """GLRenderBelowPath(self, SoGLRenderAction action)"""
        return _coin.SoNode_GLRenderBelowPath(self, *args)

    def GLRenderInPath(self, *args):
        """GLRenderInPath(self, SoGLRenderAction action)"""
        return _coin.SoNode_GLRenderInPath(self, *args)

    def GLRenderOffPath(self, *args):
        """GLRenderOffPath(self, SoGLRenderAction action)"""
        return _coin.SoNode_GLRenderOffPath(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoNode_callback(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoNode_getBoundingBox(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoNode_getMatrix(self, *args)

    def handleEvent(self, *args):
        """handleEvent(self, SoHandleEventAction action)"""
        return _coin.SoNode_handleEvent(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoNode_pick(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoNode_rayPick(self, *args)

    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoNode_search(self, *args)

    def write(self, *args):
        """write(self, SoWriteAction action)"""
        return _coin.SoNode_write(self, *args)

    def audioRender(self, *args):
        """audioRender(self, SoAudioRenderAction action)"""
        return _coin.SoNode_audioRender(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoNode_getPrimitiveCount(self, *args)

    def grabEventsSetup(self):
        """grabEventsSetup(self)"""
        return _coin.SoNode_grabEventsSetup(self)

    def grabEventsCleanup(self):
        """grabEventsCleanup(self)"""
        return _coin.SoNode_grabEventsCleanup(self)

    def startNotify(self):
        """startNotify(self)"""
        return _coin.SoNode_startNotify(self)

    def notify(self, *args):
        """notify(self, SoNotList l)"""
        return _coin.SoNode_notify(self, *args)

    def getNodeId(self):
        """getNodeId(self) -> uint32_t"""
        return _coin.SoNode_getNodeId(self)

    def getChildren(self):
        """getChildren(self) -> SoChildList"""
        return _coin.SoNode_getChildren(self)

    def writeInstance(self, *args):
        """writeInstance(self, SoOutput out)"""
        return _coin.SoNode_writeInstance(self, *args)

    def addToCopyDict(self):
        """addToCopyDict(self) -> SoNode"""
        return _coin.SoNode_addToCopyDict(self)

    def copyContents(self, *args):
        """copyContents(self, SoFieldContainer srcFrom, SbBool copyconnections)"""
        return _coin.SoNode_copyContents(self, *args)

    def copyThroughConnection(self):
        """copyThroughConnection(self) -> SoFieldContainer"""
        return _coin.SoNode_copyThroughConnection(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoNode_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getByName(*args):
        """
        getByName(SbName name) -> SoNode
        getByName(SbName name, SoNodeList l) -> int
        """
        return _coin.SoNode_getByName(*args)

    getByName = staticmethod(getByName)
    def initClass():
        """initClass()"""
        return _coin.SoNode_initClass()

    initClass = staticmethod(initClass)
    def initClasses():
        """initClasses()"""
        return _coin.SoNode_initClasses()

    initClasses = staticmethod(initClasses)
    def getNextNodeId():
        """getNextNodeId() -> uint32_t"""
        return _coin.SoNode_getNextNodeId()

    getNextNodeId = staticmethod(getNextNodeId)
    def getActionMethodIndex(*args):
        """getActionMethodIndex(SoType type) -> int"""
        return _coin.SoNode_getActionMethodIndex(*args)

    getActionMethodIndex = staticmethod(getActionMethodIndex)
    def getBoundingBoxS(*args):
        """getBoundingBoxS(SoAction action, SoNode node)"""
        return _coin.SoNode_getBoundingBoxS(*args)

    getBoundingBoxS = staticmethod(getBoundingBoxS)
    def GLRenderS(*args):
        """GLRenderS(SoAction action, SoNode node)"""
        return _coin.SoNode_GLRenderS(*args)

    GLRenderS = staticmethod(GLRenderS)
    def callbackS(*args):
        """callbackS(SoAction action, SoNode node)"""
        return _coin.SoNode_callbackS(*args)

    callbackS = staticmethod(callbackS)
    def getMatrixS(*args):
        """getMatrixS(SoAction action, SoNode node)"""
        return _coin.SoNode_getMatrixS(*args)

    getMatrixS = staticmethod(getMatrixS)
    def handleEventS(*args):
        """handleEventS(SoAction action, SoNode node)"""
        return _coin.SoNode_handleEventS(*args)

    handleEventS = staticmethod(handleEventS)
    def pickS(*args):
        """pickS(SoAction action, SoNode node)"""
        return _coin.SoNode_pickS(*args)

    pickS = staticmethod(pickS)
    def rayPickS(*args):
        """rayPickS(SoAction action, SoNode node)"""
        return _coin.SoNode_rayPickS(*args)

    rayPickS = staticmethod(rayPickS)
    def searchS(*args):
        """searchS(SoAction action, SoNode node)"""
        return _coin.SoNode_searchS(*args)

    searchS = staticmethod(searchS)
    def writeS(*args):
        """writeS(SoAction action, SoNode node)"""
        return _coin.SoNode_writeS(*args)

    writeS = staticmethod(writeS)
    def audioRenderS(*args):
        """audioRenderS(SoAction action, SoNode node)"""
        return _coin.SoNode_audioRenderS(*args)

    audioRenderS = staticmethod(audioRenderS)
    def getPrimitiveCountS(*args):
        """getPrimitiveCountS(SoAction action, SoNode node)"""
        return _coin.SoNode_getPrimitiveCountS(*args)

    getPrimitiveCountS = staticmethod(getPrimitiveCountS)
SoNode_swigregister = _coin.SoNode_swigregister
SoNode_swigregister(SoNode)

def SoNode_getCompatibilityTypes(*args):
  """SoNode_getCompatibilityTypes(SoType nodetype) -> uint32_t"""
  return _coin.SoNode_getCompatibilityTypes(*args)

def SoNode_getClassTypeId():
  """SoNode_getClassTypeId() -> SoType"""
  return _coin.SoNode_getClassTypeId()

def SoNode_getByName(*args):
  """
    getByName(SbName name) -> SoNode
    SoNode_getByName(SbName name, SoNodeList l) -> int
    """
  return _coin.SoNode_getByName(*args)

def SoNode_initClass():
  """SoNode_initClass()"""
  return _coin.SoNode_initClass()

def SoNode_initClasses():
  """SoNode_initClasses()"""
  return _coin.SoNode_initClasses()

def SoNode_getNextNodeId():
  """SoNode_getNextNodeId() -> uint32_t"""
  return _coin.SoNode_getNextNodeId()

def SoNode_getActionMethodIndex(*args):
  """SoNode_getActionMethodIndex(SoType type) -> int"""
  return _coin.SoNode_getActionMethodIndex(*args)

def SoNode_getBoundingBoxS(*args):
  """SoNode_getBoundingBoxS(SoAction action, SoNode node)"""
  return _coin.SoNode_getBoundingBoxS(*args)

def SoNode_GLRenderS(*args):
  """SoNode_GLRenderS(SoAction action, SoNode node)"""
  return _coin.SoNode_GLRenderS(*args)

def SoNode_callbackS(*args):
  """SoNode_callbackS(SoAction action, SoNode node)"""
  return _coin.SoNode_callbackS(*args)

def SoNode_getMatrixS(*args):
  """SoNode_getMatrixS(SoAction action, SoNode node)"""
  return _coin.SoNode_getMatrixS(*args)

def SoNode_handleEventS(*args):
  """SoNode_handleEventS(SoAction action, SoNode node)"""
  return _coin.SoNode_handleEventS(*args)

def SoNode_pickS(*args):
  """SoNode_pickS(SoAction action, SoNode node)"""
  return _coin.SoNode_pickS(*args)

def SoNode_rayPickS(*args):
  """SoNode_rayPickS(SoAction action, SoNode node)"""
  return _coin.SoNode_rayPickS(*args)

def SoNode_searchS(*args):
  """SoNode_searchS(SoAction action, SoNode node)"""
  return _coin.SoNode_searchS(*args)

def SoNode_writeS(*args):
  """SoNode_writeS(SoAction action, SoNode node)"""
  return _coin.SoNode_writeS(*args)

def SoNode_audioRenderS(*args):
  """SoNode_audioRenderS(SoAction action, SoNode node)"""
  return _coin.SoNode_audioRenderS(*args)

def SoNode_getPrimitiveCountS(*args):
  """SoNode_getPrimitiveCountS(SoAction action, SoNode node)"""
  return _coin.SoNode_getPrimitiveCountS(*args)

class SoSensorManager(object):
    """Proxy of C++ SoSensorManager class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSensorManager"""
        this = _coin.new_SoSensorManager()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSensorManager
    __del__ = lambda self : None;
    def insertDelaySensor(self, *args):
        """insertDelaySensor(self, SoDelayQueueSensor s)"""
        return _coin.SoSensorManager_insertDelaySensor(self, *args)

    def insertTimerSensor(self, *args):
        """insertTimerSensor(self, SoTimerQueueSensor s)"""
        return _coin.SoSensorManager_insertTimerSensor(self, *args)

    def removeDelaySensor(self, *args):
        """removeDelaySensor(self, SoDelayQueueSensor s)"""
        return _coin.SoSensorManager_removeDelaySensor(self, *args)

    def removeTimerSensor(self, *args):
        """removeTimerSensor(self, SoTimerQueueSensor s)"""
        return _coin.SoSensorManager_removeTimerSensor(self, *args)

    def rescheduleTimer(self, *args):
        """rescheduleTimer(self, SoTimerSensor s)"""
        return _coin.SoSensorManager_rescheduleTimer(self, *args)

    def removeRescheduledTimer(self, *args):
        """removeRescheduledTimer(self, SoTimerQueueSensor s)"""
        return _coin.SoSensorManager_removeRescheduledTimer(self, *args)

    def processDelayQueue(self, *args):
        """processDelayQueue(self, SbBool isidle)"""
        return _coin.SoSensorManager_processDelayQueue(self, *args)

    def processImmediateQueue(self):
        """processImmediateQueue(self)"""
        return _coin.SoSensorManager_processImmediateQueue(self)

    def processTimerQueue(self):
        """processTimerQueue(self)"""
        return _coin.SoSensorManager_processTimerQueue(self)

    def isDelaySensorPending(self):
        """isDelaySensorPending(self) -> SbBool"""
        return _coin.SoSensorManager_isDelaySensorPending(self)

    def setDelaySensorTimeout(self, *args):
        """setDelaySensorTimeout(self, SbTime t)"""
        return _coin.SoSensorManager_setDelaySensorTimeout(self, *args)

    def getDelaySensorTimeout(self):
        """getDelaySensorTimeout(self) -> SbTime"""
        return _coin.SoSensorManager_getDelaySensorTimeout(self)

    def doSelect(self, *args):
        """
        doSelect(self, int nfds, void readfds, void writefds, void exceptfds, 
            timeval userTimeOut) -> int
        """
        return _coin.SoSensorManager_doSelect(self, *args)

    def setChangedCallback(self, *args):
        """
        setChangedCallback(self, void sensorQueueChangedCB, void data)
        setChangedCallback(self, PyObject pyfunc, PyObject data)
        """
        return _coin.SoSensorManager_setChangedCallback(self, *args)

    def isTimerSensorPending(self, *args):
        """
        isTimerSensorPending(self, SbTime tm) -> SbBool
        isTimerSensorPending(self) -> PyObject
        """
        return _coin.SoSensorManager_isTimerSensorPending(self, *args)

SoSensorManager_swigregister = _coin.SoSensorManager_swigregister
SoSensorManager_swigregister(SoSensorManager)

class SoDB(object):
    """Proxy of C++ SoDB class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def init():
        """init()"""
        return _coin.SoDB_init()

    init = staticmethod(init)
    def finish():
        """finish()"""
        return _coin.SoDB_finish()

    finish = staticmethod(finish)
    def cleanup():
        """cleanup()"""
        return _coin.SoDB_cleanup()

    cleanup = staticmethod(cleanup)
    def getVersion():
        """getVersion() -> char"""
        return _coin.SoDB_getVersion()

    getVersion = staticmethod(getVersion)
    def read(*args):
        """
        read(SoInput input, SoPath path) -> SbBool
        read(SoInput input, SoBase base) -> SbBool
        read(SoInput input, SoNode rootnode) -> SbBool
        """
        return _coin.SoDB_read(*args)

    read = staticmethod(read)
    def readAll(*args):
        """readAll(SoInput input) -> SoSeparator"""
        return _coin.SoDB_readAll(*args)

    readAll = staticmethod(readAll)
    def readAllVRML(*args):
        """readAllVRML(SoInput input) -> SoVRMLGroup"""
        return _coin.SoDB_readAllVRML(*args)

    readAllVRML = staticmethod(readAllVRML)
    def isValidHeader(*args):
        """isValidHeader(char teststring) -> SbBool"""
        return _coin.SoDB_isValidHeader(*args)

    isValidHeader = staticmethod(isValidHeader)
    def registerHeader(*args):
        """
        registerHeader(SbString headerstring, SbBool isbinary, float ivversion, 
            SoDBHeaderCB precallback, SoDBHeaderCB postcallback, 
            void userdata = None) -> SbBool
        registerHeader(SbString headerstring, SbBool isbinary, float ivversion, 
            SoDBHeaderCB precallback, SoDBHeaderCB postcallback) -> SbBool
        """
        return _coin.SoDB_registerHeader(*args)

    registerHeader = staticmethod(registerHeader)
    def getHeaderData(*args):
        """
        getHeaderData(SbString headerstring, SbBool isbinary, float ivversion, 
            SoDBHeaderCB precallback, SoDBHeaderCB postcallback, 
            void userdata, SbBool substringok = 0) -> SbBool
        getHeaderData(SbString headerstring, SbBool isbinary, float ivversion, 
            SoDBHeaderCB precallback, SoDBHeaderCB postcallback, 
            void userdata) -> SbBool
        """
        return _coin.SoDB_getHeaderData(*args)

    getHeaderData = staticmethod(getHeaderData)
    def getNumHeaders():
        """getNumHeaders() -> int"""
        return _coin.SoDB_getNumHeaders()

    getNumHeaders = staticmethod(getNumHeaders)
    def getHeaderString(*args):
        """getHeaderString(int i) -> SbString"""
        return _coin.SoDB_getHeaderString(*args)

    getHeaderString = staticmethod(getHeaderString)
    def createGlobalField(*args):
        """createGlobalField(SbName name, SoType type) -> SoField"""
        return _coin.SoDB_createGlobalField(*args)

    createGlobalField = staticmethod(createGlobalField)
    def getGlobalField(*args):
        """getGlobalField(SbName name) -> SoField"""
        return _coin.SoDB_getGlobalField(*args)

    getGlobalField = staticmethod(getGlobalField)
    def renameGlobalField(*args):
        """renameGlobalField(SbName srcFrom, SbName destTo)"""
        return _coin.SoDB_renameGlobalField(*args)

    renameGlobalField = staticmethod(renameGlobalField)
    def setRealTimeInterval(*args):
        """setRealTimeInterval(SbTime interval)"""
        return _coin.SoDB_setRealTimeInterval(*args)

    setRealTimeInterval = staticmethod(setRealTimeInterval)
    def getRealTimeInterval():
        """getRealTimeInterval() -> SbTime"""
        return _coin.SoDB_getRealTimeInterval()

    getRealTimeInterval = staticmethod(getRealTimeInterval)
    def enableRealTimeSensor(*args):
        """enableRealTimeSensor(SbBool on)"""
        return _coin.SoDB_enableRealTimeSensor(*args)

    enableRealTimeSensor = staticmethod(enableRealTimeSensor)
    def getSensorManager():
        """getSensorManager() -> SoSensorManager"""
        return _coin.SoDB_getSensorManager()

    getSensorManager = staticmethod(getSensorManager)
    def setDelaySensorTimeout(*args):
        """setDelaySensorTimeout(SbTime t)"""
        return _coin.SoDB_setDelaySensorTimeout(*args)

    setDelaySensorTimeout = staticmethod(setDelaySensorTimeout)
    def getDelaySensorTimeout():
        """getDelaySensorTimeout() -> SbTime"""
        return _coin.SoDB_getDelaySensorTimeout()

    getDelaySensorTimeout = staticmethod(getDelaySensorTimeout)
    def doSelect(*args):
        """
        doSelect(int nfds, void readfds, void writefds, void exceptfds, 
            timeval usertimeout) -> int
        """
        return _coin.SoDB_doSelect(*args)

    doSelect = staticmethod(doSelect)
    def addConverter(*args):
        """addConverter(SoType srcFrom, SoType destTo, SoType converter)"""
        return _coin.SoDB_addConverter(*args)

    addConverter = staticmethod(addConverter)
    def getConverter(*args):
        """getConverter(SoType srcFrom, SoType destTo) -> SoType"""
        return _coin.SoDB_getConverter(*args)

    getConverter = staticmethod(getConverter)
    def isInitialized():
        """isInitialized() -> SbBool"""
        return _coin.SoDB_isInitialized()

    isInitialized = staticmethod(isInitialized)
    def startNotify():
        """startNotify()"""
        return _coin.SoDB_startNotify()

    startNotify = staticmethod(startNotify)
    def isNotifying():
        """isNotifying() -> SbBool"""
        return _coin.SoDB_isNotifying()

    isNotifying = staticmethod(isNotifying)
    def endNotify():
        """endNotify()"""
        return _coin.SoDB_endNotify()

    endNotify = staticmethod(endNotify)
    def addProgressCallback(*args):
        """addProgressCallback(ProgressCallbackType func, void userdata)"""
        return _coin.SoDB_addProgressCallback(*args)

    addProgressCallback = staticmethod(addProgressCallback)
    def removeProgressCallback(*args):
        """removeProgressCallback(ProgressCallbackType func, void userdata)"""
        return _coin.SoDB_removeProgressCallback(*args)

    removeProgressCallback = staticmethod(removeProgressCallback)
    def isMultiThread():
        """isMultiThread() -> SbBool"""
        return _coin.SoDB_isMultiThread()

    isMultiThread = staticmethod(isMultiThread)
    def readlock():
        """readlock()"""
        return _coin.SoDB_readlock()

    readlock = staticmethod(readlock)
    def readunlock():
        """readunlock()"""
        return _coin.SoDB_readunlock()

    readunlock = staticmethod(readunlock)
    def writelock():
        """writelock()"""
        return _coin.SoDB_writelock()

    writelock = staticmethod(writelock)
    def writeunlock():
        """writeunlock()"""
        return _coin.SoDB_writeunlock()

    writeunlock = staticmethod(writeunlock)
    def createRoute(*args):
        """createRoute(SoNode srcFrom, char eventout, SoNode destTo, char eventin)"""
        return _coin.SoDB_createRoute(*args)

    createRoute = staticmethod(createRoute)
    def removeRoute(*args):
        """removeRoute(SoNode srcFrom, char eventout, SoNode destTo, char eventin)"""
        return _coin.SoDB_removeRoute(*args)

    removeRoute = staticmethod(removeRoute)
    def __init__(self): 
        """__init__(self) -> SoDB"""
        this = _coin.new_SoDB()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoDB
    __del__ = lambda self : None;
SoDB_swigregister = _coin.SoDB_swigregister
SoDB_swigregister(SoDB)

def SoDB_init():
  """SoDB_init()"""
  return _coin.SoDB_init()

def SoDB_finish():
  """SoDB_finish()"""
  return _coin.SoDB_finish()

def SoDB_cleanup():
  """SoDB_cleanup()"""
  return _coin.SoDB_cleanup()

def SoDB_getVersion():
  """SoDB_getVersion() -> char"""
  return _coin.SoDB_getVersion()

def SoDB_read(*args):
  """
    read(SoInput input, SoPath path) -> SbBool
    read(SoInput input, SoBase base) -> SbBool
    SoDB_read(SoInput input, SoNode rootnode) -> SbBool
    """
  return _coin.SoDB_read(*args)

def SoDB_readAll(*args):
  """SoDB_readAll(SoInput input) -> SoSeparator"""
  return _coin.SoDB_readAll(*args)

def SoDB_readAllVRML(*args):
  """SoDB_readAllVRML(SoInput input) -> SoVRMLGroup"""
  return _coin.SoDB_readAllVRML(*args)

def SoDB_isValidHeader(*args):
  """SoDB_isValidHeader(char teststring) -> SbBool"""
  return _coin.SoDB_isValidHeader(*args)

def SoDB_registerHeader(*args):
  """
    registerHeader(SbString headerstring, SbBool isbinary, float ivversion, 
        SoDBHeaderCB precallback, SoDBHeaderCB postcallback, 
        void userdata = None) -> SbBool
    SoDB_registerHeader(SbString headerstring, SbBool isbinary, float ivversion, 
        SoDBHeaderCB precallback, SoDBHeaderCB postcallback) -> SbBool
    """
  return _coin.SoDB_registerHeader(*args)

def SoDB_getHeaderData(*args):
  """
    getHeaderData(SbString headerstring, SbBool isbinary, float ivversion, 
        SoDBHeaderCB precallback, SoDBHeaderCB postcallback, 
        void userdata, SbBool substringok = 0) -> SbBool
    SoDB_getHeaderData(SbString headerstring, SbBool isbinary, float ivversion, 
        SoDBHeaderCB precallback, SoDBHeaderCB postcallback, 
        void userdata) -> SbBool
    """
  return _coin.SoDB_getHeaderData(*args)

def SoDB_getNumHeaders():
  """SoDB_getNumHeaders() -> int"""
  return _coin.SoDB_getNumHeaders()

def SoDB_getHeaderString(*args):
  """SoDB_getHeaderString(int i) -> SbString"""
  return _coin.SoDB_getHeaderString(*args)

def SoDB_createGlobalField(*args):
  """SoDB_createGlobalField(SbName name, SoType type) -> SoField"""
  return _coin.SoDB_createGlobalField(*args)

def SoDB_getGlobalField(*args):
  """SoDB_getGlobalField(SbName name) -> SoField"""
  return _coin.SoDB_getGlobalField(*args)

def SoDB_renameGlobalField(*args):
  """SoDB_renameGlobalField(SbName srcFrom, SbName destTo)"""
  return _coin.SoDB_renameGlobalField(*args)

def SoDB_setRealTimeInterval(*args):
  """SoDB_setRealTimeInterval(SbTime interval)"""
  return _coin.SoDB_setRealTimeInterval(*args)

def SoDB_getRealTimeInterval():
  """SoDB_getRealTimeInterval() -> SbTime"""
  return _coin.SoDB_getRealTimeInterval()

def SoDB_enableRealTimeSensor(*args):
  """SoDB_enableRealTimeSensor(SbBool on)"""
  return _coin.SoDB_enableRealTimeSensor(*args)

def SoDB_getSensorManager():
  """SoDB_getSensorManager() -> SoSensorManager"""
  return _coin.SoDB_getSensorManager()

def SoDB_setDelaySensorTimeout(*args):
  """SoDB_setDelaySensorTimeout(SbTime t)"""
  return _coin.SoDB_setDelaySensorTimeout(*args)

def SoDB_getDelaySensorTimeout():
  """SoDB_getDelaySensorTimeout() -> SbTime"""
  return _coin.SoDB_getDelaySensorTimeout()

def SoDB_doSelect(*args):
  """
    SoDB_doSelect(int nfds, void readfds, void writefds, void exceptfds, 
        timeval usertimeout) -> int
    """
  return _coin.SoDB_doSelect(*args)

def SoDB_addConverter(*args):
  """SoDB_addConverter(SoType srcFrom, SoType destTo, SoType converter)"""
  return _coin.SoDB_addConverter(*args)

def SoDB_getConverter(*args):
  """SoDB_getConverter(SoType srcFrom, SoType destTo) -> SoType"""
  return _coin.SoDB_getConverter(*args)

def SoDB_isInitialized():
  """SoDB_isInitialized() -> SbBool"""
  return _coin.SoDB_isInitialized()

def SoDB_startNotify():
  """SoDB_startNotify()"""
  return _coin.SoDB_startNotify()

def SoDB_isNotifying():
  """SoDB_isNotifying() -> SbBool"""
  return _coin.SoDB_isNotifying()

def SoDB_endNotify():
  """SoDB_endNotify()"""
  return _coin.SoDB_endNotify()

def SoDB_addProgressCallback(*args):
  """SoDB_addProgressCallback(ProgressCallbackType func, void userdata)"""
  return _coin.SoDB_addProgressCallback(*args)

def SoDB_removeProgressCallback(*args):
  """SoDB_removeProgressCallback(ProgressCallbackType func, void userdata)"""
  return _coin.SoDB_removeProgressCallback(*args)

def SoDB_isMultiThread():
  """SoDB_isMultiThread() -> SbBool"""
  return _coin.SoDB_isMultiThread()

def SoDB_readlock():
  """SoDB_readlock()"""
  return _coin.SoDB_readlock()

def SoDB_readunlock():
  """SoDB_readunlock()"""
  return _coin.SoDB_readunlock()

def SoDB_writelock():
  """SoDB_writelock()"""
  return _coin.SoDB_writelock()

def SoDB_writeunlock():
  """SoDB_writeunlock()"""
  return _coin.SoDB_writeunlock()

def SoDB_createRoute(*args):
  """SoDB_createRoute(SoNode srcFrom, char eventout, SoNode destTo, char eventin)"""
  return _coin.SoDB_createRoute(*args)

def SoDB_removeRoute(*args):
  """SoDB_removeRoute(SoNode srcFrom, char eventout, SoNode destTo, char eventin)"""
  return _coin.SoDB_removeRoute(*args)

class SoInput(object):
    """Proxy of C++ SoInput class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SoInput
        __init__(self, SoInput dictIn) -> SoInput
        """
        this = _coin.new_SoInput(*args)
        try: self.this.append(this)
        except: self.this = this
    def findProto(self, *args):
        """findProto(self, SbName name) -> SoProto"""
        return _coin.SoInput_findProto(self, *args)

    def addProto(self, *args):
        """addProto(self, SoProto proto)"""
        return _coin.SoInput_addProto(self, *args)

    def pushProto(self, *args):
        """pushProto(self, SoProto proto)"""
        return _coin.SoInput_pushProto(self, *args)

    def getCurrentProto(self):
        """getCurrentProto(self) -> SoProto"""
        return _coin.SoInput_getCurrentProto(self)

    def popProto(self):
        """popProto(self)"""
        return _coin.SoInput_popProto(self)

    def addRoute(self, *args):
        """addRoute(self, SbName fromnode, SbName fromfield, SbName tonode, SbName tofield)"""
        return _coin.SoInput_addRoute(self, *args)

    def checkISReference(self, *args):
        """checkISReference(self, SoFieldContainer container, SbName fieldname, SbBool readok) -> SbBool"""
        return _coin.SoInput_checkISReference(self, *args)

    __swig_destroy__ = _coin.delete_SoInput
    __del__ = lambda self : None;
    def setFilePointer(self, *args):
        """setFilePointer(self, FILE newFP)"""
        return _coin.SoInput_setFilePointer(self, *args)

    def openFile(self, *args):
        """
        openFile(self, char fileName, SbBool okIfNotFound = 0) -> SbBool
        openFile(self, char fileName) -> SbBool
        """
        return _coin.SoInput_openFile(self, *args)

    def pushFile(self, *args):
        """pushFile(self, char fileName) -> SbBool"""
        return _coin.SoInput_pushFile(self, *args)

    def closeFile(self):
        """closeFile(self)"""
        return _coin.SoInput_closeFile(self)

    def isValidFile(self):
        """isValidFile(self) -> SbBool"""
        return _coin.SoInput_isValidFile(self)

    def isValidBuffer(self):
        """isValidBuffer(self) -> SbBool"""
        return _coin.SoInput_isValidBuffer(self)

    def getCurFile(self):
        """getCurFile(self) -> FILE"""
        return _coin.SoInput_getCurFile(self)

    def getCurFileName(self):
        """getCurFileName(self) -> char"""
        return _coin.SoInput_getCurFileName(self)

    def setBuffer(self, *args):
        """setBuffer(self, void bufpointer)"""
        return _coin.SoInput_setBuffer(self, *args)

    def setStringArray(self, *args):
        """setStringArray(self, char strings)"""
        return _coin.SoInput_setStringArray(self, *args)

    def getNumBytesRead(self):
        """getNumBytesRead(self) -> size_t"""
        return _coin.SoInput_getNumBytesRead(self)

    def getHeader(self):
        """getHeader(self) -> SbString"""
        return _coin.SoInput_getHeader(self)

    def getIVVersion(self):
        """getIVVersion(self) -> float"""
        return _coin.SoInput_getIVVersion(self)

    def isBinary(self):
        """isBinary(self) -> SbBool"""
        return _coin.SoInput_isBinary(self)

    def get(self, *args):
        """get(self, char c) -> SbBool"""
        return _coin.SoInput_get(self, *args)

    def getASCIIBuffer(self, *args):
        """getASCIIBuffer(self, char c) -> SbBool"""
        return _coin.SoInput_getASCIIBuffer(self, *args)

    def getASCIIFile(self, *args):
        """getASCIIFile(self, char c) -> SbBool"""
        return _coin.SoInput_getASCIIFile(self, *args)

    def readHex(self, *args):
        """readHex(self, uint32_t l) -> SbBool"""
        return _coin.SoInput_readHex(self, *args)

    def read(self, *args):
        """
        read(self, char c) -> SbBool
        read(self, char c, SbBool skip) -> SbBool
        read(self, SbString s) -> SbBool
        read(self, SbName n, SbBool validIdent = 0) -> SbBool
        read(self, SbName n) -> SbBool
        read(self, int i) -> SbBool
        read(self, unsigned int i) -> SbBool
        read(self, short s) -> SbBool
        read(self, unsigned short s) -> SbBool
        read(self, float f) -> SbBool
        read(self, double d) -> SbBool
        """
        return _coin.SoInput_read(self, *args)

    def readByte(self, *args):
        """
        readByte(self, int8_t b) -> SbBool
        readByte(self, uint8_t b) -> SbBool
        """
        return _coin.SoInput_readByte(self, *args)

    def readBinaryArray(self, *args):
        """
        readBinaryArray(self, unsigned char c, int length) -> SbBool
        readBinaryArray(self, int32_t l, int length) -> SbBool
        readBinaryArray(self, float f, int length) -> SbBool
        readBinaryArray(self, double d, int length) -> SbBool
        """
        return _coin.SoInput_readBinaryArray(self, *args)

    def eof(self):
        """eof(self) -> SbBool"""
        return _coin.SoInput_eof(self)

    def isFileVRML1(self):
        """isFileVRML1(self) -> SbBool"""
        return _coin.SoInput_isFileVRML1(self)

    def isFileVRML2(self):
        """isFileVRML2(self) -> SbBool"""
        return _coin.SoInput_isFileVRML2(self)

    def resetFilePointer(self, *args):
        """resetFilePointer(self, FILE fptr)"""
        return _coin.SoInput_resetFilePointer(self, *args)

    def getLocationString(self, *args):
        """getLocationString(self, SbString string)"""
        return _coin.SoInput_getLocationString(self, *args)

    def putBack(self, *args):
        """
        putBack(self, char c)
        putBack(self, char str)
        """
        return _coin.SoInput_putBack(self, *args)

    def addReference(self, *args):
        """
        addReference(self, SbName name, SoBase base, SbBool addToGlobalDict = 1)
        addReference(self, SbName name, SoBase base)
        """
        return _coin.SoInput_addReference(self, *args)

    def removeReference(self, *args):
        """removeReference(self, SbName name)"""
        return _coin.SoInput_removeReference(self, *args)

    def findReference(self, *args):
        """findReference(self, SbName name) -> SoBase"""
        return _coin.SoInput_findReference(self, *args)

    def addDirectoryFirst(*args):
        """addDirectoryFirst(char dirName)"""
        return _coin.SoInput_addDirectoryFirst(*args)

    addDirectoryFirst = staticmethod(addDirectoryFirst)
    def addDirectoryLast(*args):
        """addDirectoryLast(char dirName)"""
        return _coin.SoInput_addDirectoryLast(*args)

    addDirectoryLast = staticmethod(addDirectoryLast)
    def addEnvDirectoriesFirst(*args):
        """
        addEnvDirectoriesFirst(char envVarName, char separator = ":\t ")
        addEnvDirectoriesFirst(char envVarName)
        """
        return _coin.SoInput_addEnvDirectoriesFirst(*args)

    addEnvDirectoriesFirst = staticmethod(addEnvDirectoriesFirst)
    def addEnvDirectoriesLast(*args):
        """
        addEnvDirectoriesLast(char envVarName, char separator = ":\t ")
        addEnvDirectoriesLast(char envVarName)
        """
        return _coin.SoInput_addEnvDirectoriesLast(*args)

    addEnvDirectoriesLast = staticmethod(addEnvDirectoriesLast)
    def removeDirectory(*args):
        """removeDirectory(char dirName)"""
        return _coin.SoInput_removeDirectory(*args)

    removeDirectory = staticmethod(removeDirectory)
    def clearDirectories():
        """clearDirectories()"""
        return _coin.SoInput_clearDirectories()

    clearDirectories = staticmethod(clearDirectories)
    def getDirectories():
        """getDirectories() -> SbStringList"""
        return _coin.SoInput_getDirectories()

    getDirectories = staticmethod(getDirectories)
    def init():
        """init()"""
        return _coin.SoInput_init()

    init = staticmethod(init)
    def getPathname(*args):
        """
        getPathname(char filename) -> SbString
        getPathname(SbString s) -> SbString
        """
        return _coin.SoInput_getPathname(*args)

    getPathname = staticmethod(getPathname)
    def getBasename(*args):
        """
        getBasename(char filename) -> SbString
        getBasename(SbString s) -> SbString
        """
        return _coin.SoInput_getBasename(*args)

    getBasename = staticmethod(getBasename)
    def searchForFile(*args):
        """searchForFile(SbString basename, SbStringList directories, SbStringList subdirectories) -> SbString"""
        return _coin.SoInput_searchForFile(*args)

    searchForFile = staticmethod(searchForFile)
SoInput_swigregister = _coin.SoInput_swigregister
SoInput_swigregister(SoInput)

def SoInput_addDirectoryFirst(*args):
  """SoInput_addDirectoryFirst(char dirName)"""
  return _coin.SoInput_addDirectoryFirst(*args)

def SoInput_addDirectoryLast(*args):
  """SoInput_addDirectoryLast(char dirName)"""
  return _coin.SoInput_addDirectoryLast(*args)

def SoInput_addEnvDirectoriesFirst(*args):
  """
    addEnvDirectoriesFirst(char envVarName, char separator = ":\t ")
    SoInput_addEnvDirectoriesFirst(char envVarName)
    """
  return _coin.SoInput_addEnvDirectoriesFirst(*args)

def SoInput_addEnvDirectoriesLast(*args):
  """
    addEnvDirectoriesLast(char envVarName, char separator = ":\t ")
    SoInput_addEnvDirectoriesLast(char envVarName)
    """
  return _coin.SoInput_addEnvDirectoriesLast(*args)

def SoInput_removeDirectory(*args):
  """SoInput_removeDirectory(char dirName)"""
  return _coin.SoInput_removeDirectory(*args)

def SoInput_clearDirectories():
  """SoInput_clearDirectories()"""
  return _coin.SoInput_clearDirectories()

def SoInput_getDirectories():
  """SoInput_getDirectories() -> SbStringList"""
  return _coin.SoInput_getDirectories()

def SoInput_init():
  """SoInput_init()"""
  return _coin.SoInput_init()

def SoInput_getPathname(*args):
  """
    getPathname(char filename) -> SbString
    SoInput_getPathname(SbString s) -> SbString
    """
  return _coin.SoInput_getPathname(*args)

def SoInput_getBasename(*args):
  """
    getBasename(char filename) -> SbString
    SoInput_getBasename(SbString s) -> SbString
    """
  return _coin.SoInput_getBasename(*args)

def SoInput_searchForFile(*args):
  """SoInput_searchForFile(SbString basename, SbStringList directories, SbStringList subdirectories) -> SbString"""
  return _coin.SoInput_searchForFile(*args)

class SoOutput(object):
    """Proxy of C++ SoOutput class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    COUNT_REFS = _coin.SoOutput_COUNT_REFS
    WRITE = _coin.SoOutput_WRITE
    ADDRESSES = _coin.SoOutput_ADDRESSES
    REF_COUNTS = _coin.SoOutput_REF_COUNTS
    def __init__(self, *args): 
        """
        __init__(self) -> SoOutput
        __init__(self, SoOutput dictOut) -> SoOutput
        """
        this = _coin.new_SoOutput(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoOutput
    __del__ = lambda self : None;
    def setFilePointer(self, *args):
        """setFilePointer(self, FILE newFP)"""
        return _coin.SoOutput_setFilePointer(self, *args)

    def getFilePointer(self):
        """getFilePointer(self) -> FILE"""
        return _coin.SoOutput_getFilePointer(self)

    def openFile(self, *args):
        """openFile(self, char fileName) -> SbBool"""
        return _coin.SoOutput_openFile(self, *args)

    def closeFile(self):
        """closeFile(self)"""
        return _coin.SoOutput_closeFile(self)

    def setCompression(self, *args):
        """
        setCompression(self, SbName compmethod, float level = 0.5) -> SbBool
        setCompression(self, SbName compmethod) -> SbBool
        """
        return _coin.SoOutput_setCompression(self, *args)

    def getAvailableCompressionMethods(*args):
        """getAvailableCompressionMethods(unsigned int num) -> SbName"""
        return _coin.SoOutput_getAvailableCompressionMethods(*args)

    getAvailableCompressionMethods = staticmethod(getAvailableCompressionMethods)
    def setBuffer(self, *args):
        """
        setBuffer(self, void bufPointer, size_t initSize, SoOutputReallocCB reallocFunc, 
            int32_t offset = 0)
        setBuffer(self, void bufPointer, size_t initSize, SoOutputReallocCB reallocFunc)
        """
        return _coin.SoOutput_setBuffer(self, *args)

    def getBuffer(self, *args):
        """getBuffer(self, void bufPointer, size_t nBytes) -> SbBool"""
        return _coin.SoOutput_getBuffer(self, *args)

    def getBufferSize(self):
        """getBufferSize(self) -> size_t"""
        return _coin.SoOutput_getBufferSize(self)

    def resetBuffer(self):
        """resetBuffer(self)"""
        return _coin.SoOutput_resetBuffer(self)

    def setBinary(self, *args):
        """setBinary(self, SbBool flag)"""
        return _coin.SoOutput_setBinary(self, *args)

    def isBinary(self):
        """isBinary(self) -> SbBool"""
        return _coin.SoOutput_isBinary(self)

    def setHeaderString(self, *args):
        """setHeaderString(self, SbString str)"""
        return _coin.SoOutput_setHeaderString(self, *args)

    def resetHeaderString(self):
        """resetHeaderString(self)"""
        return _coin.SoOutput_resetHeaderString(self)

    def setFloatPrecision(self, *args):
        """setFloatPrecision(self, int precision)"""
        return _coin.SoOutput_setFloatPrecision(self, *args)

    def setStage(self, *args):
        """setStage(self, Stage stage)"""
        return _coin.SoOutput_setStage(self, *args)

    def getStage(self):
        """getStage(self) -> Stage"""
        return _coin.SoOutput_getStage(self)

    def incrementIndent(self, levels = 1):
        """
        incrementIndent(self, int levels = 1)
        incrementIndent(self)
        """
        return _coin.SoOutput_incrementIndent(self, levels)

    def decrementIndent(self, levels = 1):
        """
        decrementIndent(self, int levels = 1)
        decrementIndent(self)
        """
        return _coin.SoOutput_decrementIndent(self, levels)

    def write(self, *args):
        """
        write(self, char c)
        write(self, char s)
        write(self, SbString s)
        write(self, SbName n)
        write(self, int i)
        write(self, unsigned int i)
        write(self, short s)
        write(self, unsigned short s)
        write(self, float f)
        write(self, double d)
        """
        return _coin.SoOutput_write(self, *args)

    def writeBinaryArray(self, *args):
        """
        writeBinaryArray(self, unsigned char c, int length)
        writeBinaryArray(self, int32_t l, int length)
        writeBinaryArray(self, float f, int length)
        writeBinaryArray(self, double d, int length)
        """
        return _coin.SoOutput_writeBinaryArray(self, *args)

    def indent(self):
        """indent(self)"""
        return _coin.SoOutput_indent(self)

    def reset(self):
        """reset(self)"""
        return _coin.SoOutput_reset(self)

    def setCompact(self, *args):
        """setCompact(self, SbBool flag)"""
        return _coin.SoOutput_setCompact(self, *args)

    def isCompact(self):
        """isCompact(self) -> SbBool"""
        return _coin.SoOutput_isCompact(self)

    def setAnnotation(self, *args):
        """setAnnotation(self, uint32_t bits)"""
        return _coin.SoOutput_setAnnotation(self, *args)

    def getAnnotation(self):
        """getAnnotation(self) -> uint32_t"""
        return _coin.SoOutput_getAnnotation(self)

    def getDefaultASCIIHeader():
        """getDefaultASCIIHeader() -> SbString"""
        return _coin.SoOutput_getDefaultASCIIHeader()

    getDefaultASCIIHeader = staticmethod(getDefaultASCIIHeader)
    def getDefaultBinaryHeader():
        """getDefaultBinaryHeader() -> SbString"""
        return _coin.SoOutput_getDefaultBinaryHeader()

    getDefaultBinaryHeader = staticmethod(getDefaultBinaryHeader)
    def addReference(self, *args):
        """addReference(self, SoBase base) -> int"""
        return _coin.SoOutput_addReference(self, *args)

    def findReference(self, *args):
        """findReference(self, SoBase base) -> int"""
        return _coin.SoOutput_findReference(self, *args)

    def setReference(self, *args):
        """setReference(self, SoBase base, int refid)"""
        return _coin.SoOutput_setReference(self, *args)

    def addDEFNode(self, *args):
        """addDEFNode(self, SbName name)"""
        return _coin.SoOutput_addDEFNode(self, *args)

    def lookupDEFNode(self, *args):
        """lookupDEFNode(self, SbName name) -> SbBool"""
        return _coin.SoOutput_lookupDEFNode(self, *args)

    def removeDEFNode(self, *args):
        """removeDEFNode(self, SbName name)"""
        return _coin.SoOutput_removeDEFNode(self, *args)

    def pushProto(self, *args):
        """pushProto(self, SoProto proto)"""
        return _coin.SoOutput_pushProto(self, *args)

    def getCurrentProto(self):
        """getCurrentProto(self) -> SoProto"""
        return _coin.SoOutput_getCurrentProto(self)

    def popProto(self):
        """popProto(self)"""
        return _coin.SoOutput_popProto(self)

    def addRoute(self, *args):
        """
        addRoute(self, SoFieldContainer srcFrom, SbName fromfield, SoFieldContainer destTo, 
            SbName tofield)
        """
        return _coin.SoOutput_addRoute(self, *args)

    def resolveRoutes(self):
        """resolveRoutes(self)"""
        return _coin.SoOutput_resolveRoutes(self)

SoOutput_swigregister = _coin.SoOutput_swigregister
SoOutput_swigregister(SoOutput)

def SoOutput_getAvailableCompressionMethods(*args):
  """SoOutput_getAvailableCompressionMethods(unsigned int num) -> SbName"""
  return _coin.SoOutput_getAvailableCompressionMethods(*args)

def SoOutput_getDefaultASCIIHeader():
  """SoOutput_getDefaultASCIIHeader() -> SbString"""
  return _coin.SoOutput_getDefaultASCIIHeader()

def SoOutput_getDefaultBinaryHeader():
  """SoOutput_getDefaultBinaryHeader() -> SbString"""
  return _coin.SoOutput_getDefaultBinaryHeader()

class SoSFEnum(SoSField):
    """Proxy of C++ SoSFEnum class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFEnum"""
        this = _coin.new_SoSFEnum()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFEnum
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFEnum_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFEnum_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFEnum_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFEnum_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFEnum_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> int"""
        return _coin.SoSFEnum_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFEnum field) -> int"""
        return _coin.SoSFEnum___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFEnum field) -> int"""
        return _coin.SoSFEnum___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFEnum_initClass()

    initClass = staticmethod(initClass)
    def setEnums(self, *args):
        """setEnums(self, int num, int vals, SbName names)"""
        return _coin.SoSFEnum_setEnums(self, *args)

    def getNumEnums(self):
        """getNumEnums(self) -> int"""
        return _coin.SoSFEnum_getNumEnums(self)

    def getEnum(self, *args):
        """getEnum(self, int idx, SbName name) -> int"""
        return _coin.SoSFEnum_getEnum(self, *args)

    def setValue(self, *args):
        """
        setValue(self, int newvalue)
        setValue(self, SbName name)
        setValue(self, SoSFEnum other)
        """
        return _coin.SoSFEnum_setValue(self, *args)

SoSFEnum_swigregister = _coin.SoSFEnum_swigregister
SoSFEnum_swigregister(SoSFEnum)

def SoSFEnum_createInstance():
  """SoSFEnum_createInstance() -> void"""
  return _coin.SoSFEnum_createInstance()

def SoSFEnum_getClassTypeId():
  """SoSFEnum_getClassTypeId() -> SoType"""
  return _coin.SoSFEnum_getClassTypeId()

def SoSFEnum_initClass():
  """SoSFEnum_initClass()"""
  return _coin.SoSFEnum_initClass()

class SoSFFloat(SoSField):
    """Proxy of C++ SoSFFloat class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFFloat"""
        this = _coin.new_SoSFFloat()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFFloat
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFFloat_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFFloat_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFFloat_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFFloat_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFFloat_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> float"""
        return _coin.SoSFFloat_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFFloat field) -> int"""
        return _coin.SoSFFloat___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFFloat field) -> int"""
        return _coin.SoSFFloat___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFFloat_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, float newvalue)
        setValue(self, SoSFFloat other)
        """
        return _coin.SoSFFloat_setValue(self, *args)

SoSFFloat_swigregister = _coin.SoSFFloat_swigregister
SoSFFloat_swigregister(SoSFFloat)

def SoSFFloat_createInstance():
  """SoSFFloat_createInstance() -> void"""
  return _coin.SoSFFloat_createInstance()

def SoSFFloat_getClassTypeId():
  """SoSFFloat_getClassTypeId() -> SoType"""
  return _coin.SoSFFloat_getClassTypeId()

def SoSFFloat_initClass():
  """SoSFFloat_initClass()"""
  return _coin.SoSFFloat_initClass()

class SoComplexityTypeElement(SoInt32Element):
    """Proxy of C++ SoComplexityTypeElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoComplexityTypeElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoComplexityTypeElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoComplexityTypeElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoComplexityTypeElement_initClass()

    initClass = staticmethod(initClass)
    OBJECT_SPACE = _coin.SoComplexityTypeElement_OBJECT_SPACE
    SCREEN_SPACE = _coin.SoComplexityTypeElement_SCREEN_SPACE
    BOUNDING_BOX = _coin.SoComplexityTypeElement_BOUNDING_BOX
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoComplexityTypeElement_init(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, Type type)
        set(SoState state, Type type)
        """
        return _coin.SoComplexityTypeElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> Type"""
        return _coin.SoComplexityTypeElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> Type"""
        return _coin.SoComplexityTypeElement_getDefault()

    getDefault = staticmethod(getDefault)
SoComplexityTypeElement_swigregister = _coin.SoComplexityTypeElement_swigregister
SoComplexityTypeElement_swigregister(SoComplexityTypeElement)

def SoComplexityTypeElement_getClassTypeId():
  """SoComplexityTypeElement_getClassTypeId() -> SoType"""
  return _coin.SoComplexityTypeElement_getClassTypeId()

def SoComplexityTypeElement_getClassStackIndex():
  """SoComplexityTypeElement_getClassStackIndex() -> int"""
  return _coin.SoComplexityTypeElement_getClassStackIndex()

def SoComplexityTypeElement_createInstance():
  """SoComplexityTypeElement_createInstance() -> void"""
  return _coin.SoComplexityTypeElement_createInstance()

def SoComplexityTypeElement_initClass():
  """SoComplexityTypeElement_initClass()"""
  return _coin.SoComplexityTypeElement_initClass()

def SoComplexityTypeElement_set(*args):
  """
    set(SoState state, SoNode node, Type type)
    SoComplexityTypeElement_set(SoState state, Type type)
    """
  return _coin.SoComplexityTypeElement_set(*args)

def SoComplexityTypeElement_get(*args):
  """SoComplexityTypeElement_get(SoState state) -> Type"""
  return _coin.SoComplexityTypeElement_get(*args)

def SoComplexityTypeElement_getDefault():
  """SoComplexityTypeElement_getDefault() -> Type"""
  return _coin.SoComplexityTypeElement_getDefault()

class SoComplexity(SoNode):
    """Proxy of C++ SoComplexity class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoComplexity_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoComplexity_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoComplexity_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoComplexity"""
        this = _coin.new_SoComplexity()
        try: self.this.append(this)
        except: self.this = this
    OBJECT_SPACE = _coin.SoComplexity_OBJECT_SPACE
    SCREEN_SPACE = _coin.SoComplexity_SCREEN_SPACE
    BOUNDING_BOX = _coin.SoComplexity_BOUNDING_BOX
    type = _swig_property(_coin.SoComplexity_type_get, _coin.SoComplexity_type_set)
    value = _swig_property(_coin.SoComplexity_value_get, _coin.SoComplexity_value_set)
    textureQuality = _swig_property(_coin.SoComplexity_textureQuality_get, _coin.SoComplexity_textureQuality_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoComplexity_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoComplexity_callback(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoComplexity_getBoundingBox(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoComplexity_GLRender(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoComplexity_pick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoComplexity_getPrimitiveCount(self, *args)

SoComplexity_swigregister = _coin.SoComplexity_swigregister
SoComplexity_swigregister(SoComplexity)

def SoComplexity_getClassTypeId():
  """SoComplexity_getClassTypeId() -> SoType"""
  return _coin.SoComplexity_getClassTypeId()

def SoComplexity_initClass():
  """SoComplexity_initClass()"""
  return _coin.SoComplexity_initClass()

class SoDrawStyleElement(SoInt32Element):
    """Proxy of C++ SoDrawStyleElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoDrawStyleElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoDrawStyleElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoDrawStyleElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoDrawStyleElement_initClass()

    initClass = staticmethod(initClass)
    FILLED = _coin.SoDrawStyleElement_FILLED
    LINES = _coin.SoDrawStyleElement_LINES
    POINTS = _coin.SoDrawStyleElement_POINTS
    INVISIBLE = _coin.SoDrawStyleElement_INVISIBLE
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoDrawStyleElement_init(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, Style style)
        set(SoState state, Style style)
        """
        return _coin.SoDrawStyleElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> Style"""
        return _coin.SoDrawStyleElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> Style"""
        return _coin.SoDrawStyleElement_getDefault()

    getDefault = staticmethod(getDefault)
SoDrawStyleElement_swigregister = _coin.SoDrawStyleElement_swigregister
SoDrawStyleElement_swigregister(SoDrawStyleElement)

def SoDrawStyleElement_getClassTypeId():
  """SoDrawStyleElement_getClassTypeId() -> SoType"""
  return _coin.SoDrawStyleElement_getClassTypeId()

def SoDrawStyleElement_getClassStackIndex():
  """SoDrawStyleElement_getClassStackIndex() -> int"""
  return _coin.SoDrawStyleElement_getClassStackIndex()

def SoDrawStyleElement_createInstance():
  """SoDrawStyleElement_createInstance() -> void"""
  return _coin.SoDrawStyleElement_createInstance()

def SoDrawStyleElement_initClass():
  """SoDrawStyleElement_initClass()"""
  return _coin.SoDrawStyleElement_initClass()

def SoDrawStyleElement_set(*args):
  """
    set(SoState state, SoNode node, Style style)
    SoDrawStyleElement_set(SoState state, Style style)
    """
  return _coin.SoDrawStyleElement_set(*args)

def SoDrawStyleElement_get(*args):
  """SoDrawStyleElement_get(SoState state) -> Style"""
  return _coin.SoDrawStyleElement_get(*args)

def SoDrawStyleElement_getDefault():
  """SoDrawStyleElement_getDefault() -> Style"""
  return _coin.SoDrawStyleElement_getDefault()

class SoSFUShort(SoSField):
    """Proxy of C++ SoSFUShort class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFUShort"""
        this = _coin.new_SoSFUShort()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFUShort
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFUShort_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFUShort_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFUShort_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFUShort_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFUShort_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> unsigned short"""
        return _coin.SoSFUShort_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFUShort field) -> int"""
        return _coin.SoSFUShort___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFUShort field) -> int"""
        return _coin.SoSFUShort___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFUShort_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, unsigned short newvalue)
        setValue(self, SoSFUShort other)
        """
        return _coin.SoSFUShort_setValue(self, *args)

SoSFUShort_swigregister = _coin.SoSFUShort_swigregister
SoSFUShort_swigregister(SoSFUShort)

def SoSFUShort_createInstance():
  """SoSFUShort_createInstance() -> void"""
  return _coin.SoSFUShort_createInstance()

def SoSFUShort_getClassTypeId():
  """SoSFUShort_getClassTypeId() -> SoType"""
  return _coin.SoSFUShort_getClassTypeId()

def SoSFUShort_initClass():
  """SoSFUShort_initClass()"""
  return _coin.SoSFUShort_initClass()

class SoSFInt32(SoSField):
    """Proxy of C++ SoSFInt32 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFInt32"""
        this = _coin.new_SoSFInt32()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFInt32
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFInt32_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFInt32_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFInt32_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFInt32_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFInt32_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> int32_t"""
        return _coin.SoSFInt32_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFInt32 field) -> int"""
        return _coin.SoSFInt32___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFInt32 field) -> int"""
        return _coin.SoSFInt32___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFInt32_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, int32_t newvalue)
        setValue(self, SoSFInt32 other)
        """
        return _coin.SoSFInt32_setValue(self, *args)

SoSFInt32_swigregister = _coin.SoSFInt32_swigregister
SoSFInt32_swigregister(SoSFInt32)

def SoSFInt32_createInstance():
  """SoSFInt32_createInstance() -> void"""
  return _coin.SoSFInt32_createInstance()

def SoSFInt32_getClassTypeId():
  """SoSFInt32_getClassTypeId() -> SoType"""
  return _coin.SoSFInt32_getClassTypeId()

def SoSFInt32_initClass():
  """SoSFInt32_initClass()"""
  return _coin.SoSFInt32_initClass()

class SoDrawStyle(SoNode):
    """Proxy of C++ SoDrawStyle class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoDrawStyle_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoDrawStyle_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoDrawStyle_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoDrawStyle"""
        this = _coin.new_SoDrawStyle()
        try: self.this.append(this)
        except: self.this = this
    FILLED = _coin.SoDrawStyle_FILLED
    LINES = _coin.SoDrawStyle_LINES
    POINTS = _coin.SoDrawStyle_POINTS
    INVISIBLE = _coin.SoDrawStyle_INVISIBLE
    style = _swig_property(_coin.SoDrawStyle_style_get, _coin.SoDrawStyle_style_set)
    pointSize = _swig_property(_coin.SoDrawStyle_pointSize_get, _coin.SoDrawStyle_pointSize_set)
    lineWidth = _swig_property(_coin.SoDrawStyle_lineWidth_get, _coin.SoDrawStyle_lineWidth_set)
    linePattern = _swig_property(_coin.SoDrawStyle_linePattern_get, _coin.SoDrawStyle_linePattern_set)
    linePatternScaleFactor = _swig_property(_coin.SoDrawStyle_linePatternScaleFactor_get, _coin.SoDrawStyle_linePatternScaleFactor_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoDrawStyle_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoDrawStyle_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoDrawStyle_callback(self, *args)

SoDrawStyle_swigregister = _coin.SoDrawStyle_swigregister
SoDrawStyle_swigregister(SoDrawStyle)

def SoDrawStyle_getClassTypeId():
  """SoDrawStyle_getClassTypeId() -> SoType"""
  return _coin.SoDrawStyle_getClassTypeId()

def SoDrawStyle_initClass():
  """SoDrawStyle_initClass()"""
  return _coin.SoDrawStyle_initClass()

class SbVec3f(object):
    """Proxy of C++ SbVec3f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbVec3f
        __init__(self, float v) -> SbVec3f
        __init__(self, float x, float y, float z) -> SbVec3f
        __init__(self, SbVec3d v) -> SbVec3f
        __init__(self, SbVec3b v) -> SbVec3f
        __init__(self, SbVec3s v) -> SbVec3f
        __init__(self, SbVec3i32 v) -> SbVec3f
        __init__(self, SbPlane p0, SbPlane p1, SbPlane p2) -> SbVec3f
        """
        this = _coin.new_SbVec3f(*args)
        try: self.this.append(this)
        except: self.this = this
    def setValue(self, *args):
        """
        setValue(self, float v) -> SbVec3f
        setValue(self, float x, float y, float z) -> SbVec3f
        setValue(self, SbVec3f barycentric, SbVec3f v0, SbVec3f v1, SbVec3f v2) -> SbVec3f
        setValue(self, SbVec3d v) -> SbVec3f
        setValue(self, SbVec3b v) -> SbVec3f
        setValue(self, SbVec3s v) -> SbVec3f
        setValue(self, SbVec3i32 v) -> SbVec3f
        """
        return _coin.SbVec3f_setValue(self, *args)

    def getValue(self):
        """getValue(self) -> float"""
        return _coin.SbVec3f_getValue(self)

    def equals(self, *args):
        """equals(self, SbVec3f v, float tolerance) -> SbBool"""
        return _coin.SbVec3f_equals(self, *args)

    def cross(self, *args):
        """cross(self, SbVec3f v) -> SbVec3f"""
        return _coin.SbVec3f_cross(self, *args)

    def dot(self, *args):
        """dot(self, SbVec3f v) -> float"""
        return _coin.SbVec3f_dot(self, *args)

    def getClosestAxis(self):
        """getClosestAxis(self) -> SbVec3f"""
        return _coin.SbVec3f_getClosestAxis(self)

    def length(self):
        """length(self) -> float"""
        return _coin.SbVec3f_length(self)

    def sqrLength(self):
        """sqrLength(self) -> float"""
        return _coin.SbVec3f_sqrLength(self)

    def normalize(self):
        """normalize(self) -> float"""
        return _coin.SbVec3f_normalize(self)

    def negate(self):
        """negate(self)"""
        return _coin.SbVec3f_negate(self)

    def __imul__(self, *args):
        """__imul__(self, float d) -> SbVec3f"""
        return _coin.SbVec3f___imul__(self, *args)

    def __idiv__(self, *args):
        """__idiv__(self, float d) -> SbVec3f"""
        return _coin.SbVec3f___idiv__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, SbVec3f v) -> SbVec3f"""
        return _coin.SbVec3f___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, SbVec3f v) -> SbVec3f"""
        return _coin.SbVec3f___isub__(self, *args)

    def __neg__(self):
        """__neg__(self) -> SbVec3f"""
        return _coin.SbVec3f___neg__(self)

    def output(self, *args):
        """output(self, FILE fp)"""
        return _coin.SbVec3f_output(self, *args)

    def __add__(self, *args):
        """__add__(self, SbVec3f u) -> SbVec3f"""
        return _coin.SbVec3f___add__(self, *args)

    def __sub__(self, *args):
        """__sub__(self, SbVec3f u) -> SbVec3f"""
        return _coin.SbVec3f___sub__(self, *args)

    def __mul__(self, *args):
        """
        __mul__(self, float d) -> SbVec3f
        __mul__(self, SbMatrix m) -> SbVec3f
        """
        return _coin.SbVec3f___mul__(self, *args)

    def __rmul__(self, *args):
        """__rmul__(self, float d) -> SbVec3f"""
        return _coin.SbVec3f___rmul__(self, *args)

    def __div__(self, *args):
        """__div__(self, float d) -> SbVec3f"""
        return _coin.SbVec3f___div__(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SbVec3f u) -> int"""
        return _coin.SbVec3f___eq__(self, *args)

    def __nq__(self, *args):
        """__nq__(self, SbVec3f u) -> int"""
        return _coin.SbVec3f___nq__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> float"""
        return _coin.SbVec3f___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, float value)"""
        return _coin.SbVec3f___setitem__(self, *args)

    def __iter__(self):
       for i in range(3):
          yield self[i]
       
    def __len__(self):
          return 3

    __swig_destroy__ = _coin.delete_SbVec3f
    __del__ = lambda self : None;
SbVec3f_swigregister = _coin.SbVec3f_swigregister
SbVec3f_swigregister(SbVec3f)

class SbColor(SbVec3f):
    """Proxy of C++ SbColor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbColor
        __init__(self, SbVec3f v) -> SbColor
        __init__(self, float rgb) -> SbColor
        __init__(self, float r, float g, float b) -> SbColor
        """
        this = _coin.new_SbColor(*args)
        try: self.this.append(this)
        except: self.this = this
    def setHSVValue(self, *args):
        """
        setHSVValue(self, float h, float s, float v) -> SbColor
        setHSVValue(self, float hsv) -> SbColor
        """
        return _coin.SbColor_setHSVValue(self, *args)

    def getHSVValue(self):
        """getHSVValue(self)"""
        return _coin.SbColor_getHSVValue(self)

    def setPackedValue(self, *args):
        """setPackedValue(self, uint32_t rgba, float transparency) -> SbColor"""
        return _coin.SbColor_setPackedValue(self, *args)

    def getPackedValue(self, transparency = 0.0):
        """
        getPackedValue(self, float transparency = 0.0) -> uint32_t
        getPackedValue(self) -> uint32_t
        """
        return _coin.SbColor_getPackedValue(self, transparency)

    def __add__(self, *args):
        """__add__(self, SbColor u) -> SbColor"""
        return _coin.SbColor___add__(self, *args)

    def __sub__(self, *args):
        """__sub__(self, SbColor u) -> SbColor"""
        return _coin.SbColor___sub__(self, *args)

    def __mul__(self, *args):
        """__mul__(self, float d) -> SbColor"""
        return _coin.SbColor___mul__(self, *args)

    def __rmul__(self, *args):
        """__rmul__(self, float d) -> SbColor"""
        return _coin.SbColor___rmul__(self, *args)

    def __div__(self, *args):
        """__div__(self, float d) -> SbColor"""
        return _coin.SbColor___div__(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SbColor u) -> int"""
        return _coin.SbColor___eq__(self, *args)

    def __nq__(self, *args):
        """__nq__(self, SbColor u) -> int"""
        return _coin.SbColor___nq__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> float"""
        return _coin.SbColor___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, float value)"""
        return _coin.SbColor___setitem__(self, *args)

    __swig_destroy__ = _coin.delete_SbColor
    __del__ = lambda self : None;
SbColor_swigregister = _coin.SbColor_swigregister
SbColor_swigregister(SbColor)

SO_LAZY_SHINY_THRESHOLD = _coin.SO_LAZY_SHINY_THRESHOLD
class SoLazyElement(SoElement):
    """Proxy of C++ SoLazyElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoLazyElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoLazyElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoLazyElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoLazyElement_initClass()

    initClass = staticmethod(initClass)
    LIGHT_MODEL_CASE = _coin.SoLazyElement_LIGHT_MODEL_CASE
    COLOR_MATERIAL_CASE = _coin.SoLazyElement_COLOR_MATERIAL_CASE
    DIFFUSE_CASE = _coin.SoLazyElement_DIFFUSE_CASE
    AMBIENT_CASE = _coin.SoLazyElement_AMBIENT_CASE
    EMISSIVE_CASE = _coin.SoLazyElement_EMISSIVE_CASE
    SPECULAR_CASE = _coin.SoLazyElement_SPECULAR_CASE
    SHININESS_CASE = _coin.SoLazyElement_SHININESS_CASE
    BLENDING_CASE = _coin.SoLazyElement_BLENDING_CASE
    TRANSPARENCY_CASE = _coin.SoLazyElement_TRANSPARENCY_CASE
    VERTEXORDERING_CASE = _coin.SoLazyElement_VERTEXORDERING_CASE
    TWOSIDE_CASE = _coin.SoLazyElement_TWOSIDE_CASE
    CULLING_CASE = _coin.SoLazyElement_CULLING_CASE
    SHADE_MODEL_CASE = _coin.SoLazyElement_SHADE_MODEL_CASE
    GLIMAGE_CASE = _coin.SoLazyElement_GLIMAGE_CASE
    ALPHATEST_CASE = _coin.SoLazyElement_ALPHATEST_CASE
    LAZYCASES_LAST = _coin.SoLazyElement_LAZYCASES_LAST
    LIGHT_MODEL_MASK = _coin.SoLazyElement_LIGHT_MODEL_MASK
    COLOR_MATERIAL_MASK = _coin.SoLazyElement_COLOR_MATERIAL_MASK
    DIFFUSE_MASK = _coin.SoLazyElement_DIFFUSE_MASK
    AMBIENT_MASK = _coin.SoLazyElement_AMBIENT_MASK
    EMISSIVE_MASK = _coin.SoLazyElement_EMISSIVE_MASK
    SPECULAR_MASK = _coin.SoLazyElement_SPECULAR_MASK
    SHININESS_MASK = _coin.SoLazyElement_SHININESS_MASK
    TRANSPARENCY_MASK = _coin.SoLazyElement_TRANSPARENCY_MASK
    BLENDING_MASK = _coin.SoLazyElement_BLENDING_MASK
    VERTEXORDERING_MASK = _coin.SoLazyElement_VERTEXORDERING_MASK
    TWOSIDE_MASK = _coin.SoLazyElement_TWOSIDE_MASK
    CULLING_MASK = _coin.SoLazyElement_CULLING_MASK
    SHADE_MODEL_MASK = _coin.SoLazyElement_SHADE_MODEL_MASK
    GLIMAGE_MASK = _coin.SoLazyElement_GLIMAGE_MASK
    ALPHATEST_MASK = _coin.SoLazyElement_ALPHATEST_MASK
    ALL_MASK = _coin.SoLazyElement_ALL_MASK
    OTHER_COLOR_MASK = _coin.SoLazyElement_OTHER_COLOR_MASK
    ALL_COLOR_MASK = _coin.SoLazyElement_ALL_COLOR_MASK
    NO_COLOR_MASK = _coin.SoLazyElement_NO_COLOR_MASK
    ALL_BUT_DIFFUSE_MASK = _coin.SoLazyElement_ALL_BUT_DIFFUSE_MASK
    DIFFUSE_ONLY_MASK = _coin.SoLazyElement_DIFFUSE_ONLY_MASK
    BASE_COLOR = _coin.SoLazyElement_BASE_COLOR
    PHONG = _coin.SoLazyElement_PHONG
    CW = _coin.SoLazyElement_CW
    CCW = _coin.SoLazyElement_CCW
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoLazyElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoLazyElement_push(self, *args)

    def matches(self, *args):
        """matches(self, SoElement arg0) -> SbBool"""
        return _coin.SoLazyElement_matches(self, *args)

    def copyMatchInfo(self):
        """copyMatchInfo(self) -> SoElement"""
        return _coin.SoLazyElement_copyMatchInfo(self)

    def setToDefault(*args):
        """setToDefault(SoState state)"""
        return _coin.SoLazyElement_setToDefault(*args)

    setToDefault = staticmethod(setToDefault)
    def setDiffuse(*args):
        """
        setDiffuse(SoState state, SoNode node, int32_t numcolors, SbColor colors, 
            SoColorPacker packer)
        """
        return _coin.SoLazyElement_setDiffuse(*args)

    setDiffuse = staticmethod(setDiffuse)
    def setTransparency(*args):
        """
        setTransparency(SoState state, SoNode node, int32_t numvalues, float transparency, 
            SoColorPacker packer)
        """
        return _coin.SoLazyElement_setTransparency(*args)

    setTransparency = staticmethod(setTransparency)
    def setColorIndices(*args):
        """setColorIndices(SoState state, SoNode node, int32_t numindices, int32_t indices)"""
        return _coin.SoLazyElement_setColorIndices(*args)

    setColorIndices = staticmethod(setColorIndices)
    def setAmbient(*args):
        """setAmbient(SoState state, SbColor color)"""
        return _coin.SoLazyElement_setAmbient(*args)

    setAmbient = staticmethod(setAmbient)
    def setEmissive(*args):
        """setEmissive(SoState state, SbColor color)"""
        return _coin.SoLazyElement_setEmissive(*args)

    setEmissive = staticmethod(setEmissive)
    def setSpecular(*args):
        """setSpecular(SoState state, SbColor color)"""
        return _coin.SoLazyElement_setSpecular(*args)

    setSpecular = staticmethod(setSpecular)
    def setShininess(*args):
        """setShininess(SoState state, float value)"""
        return _coin.SoLazyElement_setShininess(*args)

    setShininess = staticmethod(setShininess)
    def setColorMaterial(*args):
        """setColorMaterial(SoState state, SbBool value)"""
        return _coin.SoLazyElement_setColorMaterial(*args)

    setColorMaterial = staticmethod(setColorMaterial)
    def enableBlending(*args):
        """enableBlending(SoState state, int sfactor, int dfactor)"""
        return _coin.SoLazyElement_enableBlending(*args)

    enableBlending = staticmethod(enableBlending)
    def enableSeparateBlending(*args):
        """
        enableSeparateBlending(SoState state, int sfactor, int dfactor, int alpha_sfactor, 
            int alpha_dfactor)
        """
        return _coin.SoLazyElement_enableSeparateBlending(*args)

    enableSeparateBlending = staticmethod(enableSeparateBlending)
    def disableBlending(*args):
        """disableBlending(SoState state)"""
        return _coin.SoLazyElement_disableBlending(*args)

    disableBlending = staticmethod(disableBlending)
    def setLightModel(*args):
        """setLightModel(SoState state, int32_t model)"""
        return _coin.SoLazyElement_setLightModel(*args)

    setLightModel = staticmethod(setLightModel)
    def setVertexOrdering(*args):
        """setVertexOrdering(SoState state, VertexOrdering ordering)"""
        return _coin.SoLazyElement_setVertexOrdering(*args)

    setVertexOrdering = staticmethod(setVertexOrdering)
    def setBackfaceCulling(*args):
        """setBackfaceCulling(SoState state, SbBool onoff)"""
        return _coin.SoLazyElement_setBackfaceCulling(*args)

    setBackfaceCulling = staticmethod(setBackfaceCulling)
    def setTwosideLighting(*args):
        """setTwosideLighting(SoState state, SbBool onoff)"""
        return _coin.SoLazyElement_setTwosideLighting(*args)

    setTwosideLighting = staticmethod(setTwosideLighting)
    def setShadeModel(*args):
        """setShadeModel(SoState state, SbBool flatshading)"""
        return _coin.SoLazyElement_setShadeModel(*args)

    setShadeModel = staticmethod(setShadeModel)
    def setGLImageId(*args):
        """setGLImageId(SoState state, uint32_t glimageid, SbBool alphatest)"""
        return _coin.SoLazyElement_setGLImageId(*args)

    setGLImageId = staticmethod(setGLImageId)
    def setAlphaTest(*args):
        """setAlphaTest(SoState state, SbBool onoff)"""
        return _coin.SoLazyElement_setAlphaTest(*args)

    setAlphaTest = staticmethod(setAlphaTest)
    def getDiffuse(*args):
        """getDiffuse(SoState state, int index) -> SbColor"""
        return _coin.SoLazyElement_getDiffuse(*args)

    getDiffuse = staticmethod(getDiffuse)
    def getTransparency(*args):
        """getTransparency(SoState arg0, int index) -> float"""
        return _coin.SoLazyElement_getTransparency(*args)

    getTransparency = staticmethod(getTransparency)
    def getPackedColors(*args):
        """getPackedColors(SoState arg0) -> uint32_t"""
        return _coin.SoLazyElement_getPackedColors(*args)

    getPackedColors = staticmethod(getPackedColors)
    def getColorIndices(*args):
        """getColorIndices(SoState arg0) -> int32_t"""
        return _coin.SoLazyElement_getColorIndices(*args)

    getColorIndices = staticmethod(getColorIndices)
    def getColorIndex(*args):
        """getColorIndex(SoState arg0, int num) -> int32_t"""
        return _coin.SoLazyElement_getColorIndex(*args)

    getColorIndex = staticmethod(getColorIndex)
    def getAmbient(*args):
        """getAmbient(SoState arg0) -> SbColor"""
        return _coin.SoLazyElement_getAmbient(*args)

    getAmbient = staticmethod(getAmbient)
    def getEmissive(*args):
        """getEmissive(SoState arg0) -> SbColor"""
        return _coin.SoLazyElement_getEmissive(*args)

    getEmissive = staticmethod(getEmissive)
    def getSpecular(*args):
        """getSpecular(SoState arg0) -> SbColor"""
        return _coin.SoLazyElement_getSpecular(*args)

    getSpecular = staticmethod(getSpecular)
    def getShininess(*args):
        """getShininess(SoState arg0) -> float"""
        return _coin.SoLazyElement_getShininess(*args)

    getShininess = staticmethod(getShininess)
    def getColorMaterial(*args):
        """getColorMaterial(SoState arg0) -> SbBool"""
        return _coin.SoLazyElement_getColorMaterial(*args)

    getColorMaterial = staticmethod(getColorMaterial)
    def getBlending(*args):
        """getBlending(SoState arg0, int sfactor, int dfactor) -> SbBool"""
        return _coin.SoLazyElement_getBlending(*args)

    getBlending = staticmethod(getBlending)
    def getAlphaBlending(*args):
        """getAlphaBlending(SoState arg0, int sfactor, int dfactor) -> SbBool"""
        return _coin.SoLazyElement_getAlphaBlending(*args)

    getAlphaBlending = staticmethod(getAlphaBlending)
    def getLightModel(*args):
        """getLightModel(SoState arg0) -> int32_t"""
        return _coin.SoLazyElement_getLightModel(*args)

    getLightModel = staticmethod(getLightModel)
    def getAlphaTest(*args):
        """getAlphaTest(SoState state) -> SbBool"""
        return _coin.SoLazyElement_getAlphaTest(*args)

    getAlphaTest = staticmethod(getAlphaTest)
    def getNumDiffuse(self):
        """getNumDiffuse(self) -> int32_t"""
        return _coin.SoLazyElement_getNumDiffuse(self)

    def getNumTransparencies(self):
        """getNumTransparencies(self) -> int32_t"""
        return _coin.SoLazyElement_getNumTransparencies(self)

    def getNumColorIndices(self):
        """getNumColorIndices(self) -> int32_t"""
        return _coin.SoLazyElement_getNumColorIndices(self)

    def isPacked(self):
        """isPacked(self) -> SbBool"""
        return _coin.SoLazyElement_isPacked(self)

    def isTransparent(self):
        """isTransparent(self) -> SbBool"""
        return _coin.SoLazyElement_isTransparent(self)

    def getInstance(*args):
        """getInstance(SoState state) -> SoLazyElement"""
        return _coin.SoLazyElement_getInstance(*args)

    getInstance = staticmethod(getInstance)
    def getDefaultAmbientIntensity():
        """getDefaultAmbientIntensity() -> float"""
        return _coin.SoLazyElement_getDefaultAmbientIntensity()

    getDefaultAmbientIntensity = staticmethod(getDefaultAmbientIntensity)
    def getDefaultDiffuse():
        """getDefaultDiffuse() -> SbColor"""
        return _coin.SoLazyElement_getDefaultDiffuse()

    getDefaultDiffuse = staticmethod(getDefaultDiffuse)
    def getDefaultAmbient():
        """getDefaultAmbient() -> SbColor"""
        return _coin.SoLazyElement_getDefaultAmbient()

    getDefaultAmbient = staticmethod(getDefaultAmbient)
    def getDefaultSpecular():
        """getDefaultSpecular() -> SbColor"""
        return _coin.SoLazyElement_getDefaultSpecular()

    getDefaultSpecular = staticmethod(getDefaultSpecular)
    def getDefaultEmissive():
        """getDefaultEmissive() -> SbColor"""
        return _coin.SoLazyElement_getDefaultEmissive()

    getDefaultEmissive = staticmethod(getDefaultEmissive)
    def getDefaultShininess():
        """getDefaultShininess() -> float"""
        return _coin.SoLazyElement_getDefaultShininess()

    getDefaultShininess = staticmethod(getDefaultShininess)
    def getDefaultPacked():
        """getDefaultPacked() -> uint32_t"""
        return _coin.SoLazyElement_getDefaultPacked()

    getDefaultPacked = staticmethod(getDefaultPacked)
    def getDefaultTransparency():
        """getDefaultTransparency() -> float"""
        return _coin.SoLazyElement_getDefaultTransparency()

    getDefaultTransparency = staticmethod(getDefaultTransparency)
    def getDefaultLightModel():
        """getDefaultLightModel() -> int32_t"""
        return _coin.SoLazyElement_getDefaultLightModel()

    getDefaultLightModel = staticmethod(getDefaultLightModel)
    def getDefaultColorIndex():
        """getDefaultColorIndex() -> int32_t"""
        return _coin.SoLazyElement_getDefaultColorIndex()

    getDefaultColorIndex = staticmethod(getDefaultColorIndex)
    def setMaterials(*args):
        """
        setMaterials(SoState state, SoNode node, uint32_t bitmask, SoColorPacker cPacker, 
            SbColor diffuse, int numdiffuse, 
            float transp, int numtransp, SbColor ambient, 
            SbColor emissive, SbColor specular, float shininess, 
            SbBool istransparent)
        """
        return _coin.SoLazyElement_setMaterials(*args)

    setMaterials = staticmethod(setMaterials)
    def getWInstance(*args):
        """getWInstance(SoState state) -> SoLazyElement"""
        return _coin.SoLazyElement_getWInstance(*args)

    getWInstance = staticmethod(getWInstance)
    def getPackedPointer(self):
        """getPackedPointer(self) -> uint32_t"""
        return _coin.SoLazyElement_getPackedPointer(self)

    def getDiffusePointer(self):
        """getDiffusePointer(self) -> SbColor"""
        return _coin.SoLazyElement_getDiffusePointer(self)

    def getColorIndexPointer(self):
        """getColorIndexPointer(self) -> int32_t"""
        return _coin.SoLazyElement_getColorIndexPointer(self)

    def getTransparencyPointer(self):
        """getTransparencyPointer(self) -> float"""
        return _coin.SoLazyElement_getTransparencyPointer(self)

    def setTransparencyType(*args):
        """setTransparencyType(SoState state, int32_t type)"""
        return _coin.SoLazyElement_setTransparencyType(*args)

    setTransparencyType = staticmethod(setTransparencyType)
SoLazyElement_swigregister = _coin.SoLazyElement_swigregister
SoLazyElement_swigregister(SoLazyElement)

def SoLazyElement_getClassTypeId():
  """SoLazyElement_getClassTypeId() -> SoType"""
  return _coin.SoLazyElement_getClassTypeId()

def SoLazyElement_getClassStackIndex():
  """SoLazyElement_getClassStackIndex() -> int"""
  return _coin.SoLazyElement_getClassStackIndex()

def SoLazyElement_createInstance():
  """SoLazyElement_createInstance() -> void"""
  return _coin.SoLazyElement_createInstance()

def SoLazyElement_initClass():
  """SoLazyElement_initClass()"""
  return _coin.SoLazyElement_initClass()

def SoLazyElement_setToDefault(*args):
  """SoLazyElement_setToDefault(SoState state)"""
  return _coin.SoLazyElement_setToDefault(*args)

def SoLazyElement_setDiffuse(*args):
  """
    SoLazyElement_setDiffuse(SoState state, SoNode node, int32_t numcolors, SbColor colors, 
        SoColorPacker packer)
    """
  return _coin.SoLazyElement_setDiffuse(*args)

def SoLazyElement_setTransparency(*args):
  """
    SoLazyElement_setTransparency(SoState state, SoNode node, int32_t numvalues, float transparency, 
        SoColorPacker packer)
    """
  return _coin.SoLazyElement_setTransparency(*args)

def SoLazyElement_setColorIndices(*args):
  """SoLazyElement_setColorIndices(SoState state, SoNode node, int32_t numindices, int32_t indices)"""
  return _coin.SoLazyElement_setColorIndices(*args)

def SoLazyElement_setAmbient(*args):
  """SoLazyElement_setAmbient(SoState state, SbColor color)"""
  return _coin.SoLazyElement_setAmbient(*args)

def SoLazyElement_setEmissive(*args):
  """SoLazyElement_setEmissive(SoState state, SbColor color)"""
  return _coin.SoLazyElement_setEmissive(*args)

def SoLazyElement_setSpecular(*args):
  """SoLazyElement_setSpecular(SoState state, SbColor color)"""
  return _coin.SoLazyElement_setSpecular(*args)

def SoLazyElement_setShininess(*args):
  """SoLazyElement_setShininess(SoState state, float value)"""
  return _coin.SoLazyElement_setShininess(*args)

def SoLazyElement_setColorMaterial(*args):
  """SoLazyElement_setColorMaterial(SoState state, SbBool value)"""
  return _coin.SoLazyElement_setColorMaterial(*args)

def SoLazyElement_enableBlending(*args):
  """SoLazyElement_enableBlending(SoState state, int sfactor, int dfactor)"""
  return _coin.SoLazyElement_enableBlending(*args)

def SoLazyElement_enableSeparateBlending(*args):
  """
    SoLazyElement_enableSeparateBlending(SoState state, int sfactor, int dfactor, int alpha_sfactor, 
        int alpha_dfactor)
    """
  return _coin.SoLazyElement_enableSeparateBlending(*args)

def SoLazyElement_disableBlending(*args):
  """SoLazyElement_disableBlending(SoState state)"""
  return _coin.SoLazyElement_disableBlending(*args)

def SoLazyElement_setLightModel(*args):
  """SoLazyElement_setLightModel(SoState state, int32_t model)"""
  return _coin.SoLazyElement_setLightModel(*args)

def SoLazyElement_setVertexOrdering(*args):
  """SoLazyElement_setVertexOrdering(SoState state, VertexOrdering ordering)"""
  return _coin.SoLazyElement_setVertexOrdering(*args)

def SoLazyElement_setBackfaceCulling(*args):
  """SoLazyElement_setBackfaceCulling(SoState state, SbBool onoff)"""
  return _coin.SoLazyElement_setBackfaceCulling(*args)

def SoLazyElement_setTwosideLighting(*args):
  """SoLazyElement_setTwosideLighting(SoState state, SbBool onoff)"""
  return _coin.SoLazyElement_setTwosideLighting(*args)

def SoLazyElement_setShadeModel(*args):
  """SoLazyElement_setShadeModel(SoState state, SbBool flatshading)"""
  return _coin.SoLazyElement_setShadeModel(*args)

def SoLazyElement_setGLImageId(*args):
  """SoLazyElement_setGLImageId(SoState state, uint32_t glimageid, SbBool alphatest)"""
  return _coin.SoLazyElement_setGLImageId(*args)

def SoLazyElement_setAlphaTest(*args):
  """SoLazyElement_setAlphaTest(SoState state, SbBool onoff)"""
  return _coin.SoLazyElement_setAlphaTest(*args)

def SoLazyElement_getDiffuse(*args):
  """SoLazyElement_getDiffuse(SoState state, int index) -> SbColor"""
  return _coin.SoLazyElement_getDiffuse(*args)

def SoLazyElement_getTransparency(*args):
  """SoLazyElement_getTransparency(SoState arg0, int index) -> float"""
  return _coin.SoLazyElement_getTransparency(*args)

def SoLazyElement_getPackedColors(*args):
  """SoLazyElement_getPackedColors(SoState arg0) -> uint32_t"""
  return _coin.SoLazyElement_getPackedColors(*args)

def SoLazyElement_getColorIndices(*args):
  """SoLazyElement_getColorIndices(SoState arg0) -> int32_t"""
  return _coin.SoLazyElement_getColorIndices(*args)

def SoLazyElement_getColorIndex(*args):
  """SoLazyElement_getColorIndex(SoState arg0, int num) -> int32_t"""
  return _coin.SoLazyElement_getColorIndex(*args)

def SoLazyElement_getAmbient(*args):
  """SoLazyElement_getAmbient(SoState arg0) -> SbColor"""
  return _coin.SoLazyElement_getAmbient(*args)

def SoLazyElement_getEmissive(*args):
  """SoLazyElement_getEmissive(SoState arg0) -> SbColor"""
  return _coin.SoLazyElement_getEmissive(*args)

def SoLazyElement_getSpecular(*args):
  """SoLazyElement_getSpecular(SoState arg0) -> SbColor"""
  return _coin.SoLazyElement_getSpecular(*args)

def SoLazyElement_getShininess(*args):
  """SoLazyElement_getShininess(SoState arg0) -> float"""
  return _coin.SoLazyElement_getShininess(*args)

def SoLazyElement_getColorMaterial(*args):
  """SoLazyElement_getColorMaterial(SoState arg0) -> SbBool"""
  return _coin.SoLazyElement_getColorMaterial(*args)

def SoLazyElement_getBlending(*args):
  """SoLazyElement_getBlending(SoState arg0, int sfactor, int dfactor) -> SbBool"""
  return _coin.SoLazyElement_getBlending(*args)

def SoLazyElement_getAlphaBlending(*args):
  """SoLazyElement_getAlphaBlending(SoState arg0, int sfactor, int dfactor) -> SbBool"""
  return _coin.SoLazyElement_getAlphaBlending(*args)

def SoLazyElement_getLightModel(*args):
  """SoLazyElement_getLightModel(SoState arg0) -> int32_t"""
  return _coin.SoLazyElement_getLightModel(*args)

def SoLazyElement_getAlphaTest(*args):
  """SoLazyElement_getAlphaTest(SoState state) -> SbBool"""
  return _coin.SoLazyElement_getAlphaTest(*args)

def SoLazyElement_getInstance(*args):
  """SoLazyElement_getInstance(SoState state) -> SoLazyElement"""
  return _coin.SoLazyElement_getInstance(*args)

def SoLazyElement_getDefaultAmbientIntensity():
  """SoLazyElement_getDefaultAmbientIntensity() -> float"""
  return _coin.SoLazyElement_getDefaultAmbientIntensity()

def SoLazyElement_getDefaultDiffuse():
  """SoLazyElement_getDefaultDiffuse() -> SbColor"""
  return _coin.SoLazyElement_getDefaultDiffuse()

def SoLazyElement_getDefaultAmbient():
  """SoLazyElement_getDefaultAmbient() -> SbColor"""
  return _coin.SoLazyElement_getDefaultAmbient()

def SoLazyElement_getDefaultSpecular():
  """SoLazyElement_getDefaultSpecular() -> SbColor"""
  return _coin.SoLazyElement_getDefaultSpecular()

def SoLazyElement_getDefaultEmissive():
  """SoLazyElement_getDefaultEmissive() -> SbColor"""
  return _coin.SoLazyElement_getDefaultEmissive()

def SoLazyElement_getDefaultShininess():
  """SoLazyElement_getDefaultShininess() -> float"""
  return _coin.SoLazyElement_getDefaultShininess()

def SoLazyElement_getDefaultPacked():
  """SoLazyElement_getDefaultPacked() -> uint32_t"""
  return _coin.SoLazyElement_getDefaultPacked()

def SoLazyElement_getDefaultTransparency():
  """SoLazyElement_getDefaultTransparency() -> float"""
  return _coin.SoLazyElement_getDefaultTransparency()

def SoLazyElement_getDefaultLightModel():
  """SoLazyElement_getDefaultLightModel() -> int32_t"""
  return _coin.SoLazyElement_getDefaultLightModel()

def SoLazyElement_getDefaultColorIndex():
  """SoLazyElement_getDefaultColorIndex() -> int32_t"""
  return _coin.SoLazyElement_getDefaultColorIndex()

def SoLazyElement_setMaterials(*args):
  """
    SoLazyElement_setMaterials(SoState state, SoNode node, uint32_t bitmask, SoColorPacker cPacker, 
        SbColor diffuse, int numdiffuse, 
        float transp, int numtransp, SbColor ambient, 
        SbColor emissive, SbColor specular, float shininess, 
        SbBool istransparent)
    """
  return _coin.SoLazyElement_setMaterials(*args)

def SoLazyElement_getWInstance(*args):
  """SoLazyElement_getWInstance(SoState state) -> SoLazyElement"""
  return _coin.SoLazyElement_getWInstance(*args)

def SoLazyElement_setTransparencyType(*args):
  """SoLazyElement_setTransparencyType(SoState state, int32_t type)"""
  return _coin.SoLazyElement_setTransparencyType(*args)

class SoColorPacker(object):
    """Proxy of C++ SoColorPacker class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoColorPacker"""
        this = _coin.new_SoColorPacker()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoColorPacker
    __del__ = lambda self : None;
    def getPackedColors(self):
        """getPackedColors(self) -> uint32_t"""
        return _coin.SoColorPacker_getPackedColors(self)

    def diffuseMatch(self, *args):
        """diffuseMatch(self, uint32_t nodeid) -> SbBool"""
        return _coin.SoColorPacker_diffuseMatch(self, *args)

    def transpMatch(self, *args):
        """transpMatch(self, uint32_t nodeid) -> SbBool"""
        return _coin.SoColorPacker_transpMatch(self, *args)

    def setNodeIds(self, *args):
        """setNodeIds(self, uint32_t diffuse, uint32_t transp)"""
        return _coin.SoColorPacker_setNodeIds(self, *args)

    def getSize(self):
        """getSize(self) -> int32_t"""
        return _coin.SoColorPacker_getSize(self)

    def reallocate(self, *args):
        """reallocate(self, int32_t size)"""
        return _coin.SoColorPacker_reallocate(self, *args)

    def getDiffuseId(self):
        """getDiffuseId(self) -> uint32_t"""
        return _coin.SoColorPacker_getDiffuseId(self)

    def getTranspId(self):
        """getTranspId(self) -> uint32_t"""
        return _coin.SoColorPacker_getTranspId(self)

SoColorPacker_swigregister = _coin.SoColorPacker_swigregister
SoColorPacker_swigregister(SoColorPacker)

class SoLightModel(SoNode):
    """Proxy of C++ SoLightModel class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoLightModel_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoLightModel_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoLightModel_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoLightModel"""
        this = _coin.new_SoLightModel()
        try: self.this.append(this)
        except: self.this = this
    BASE_COLOR = _coin.SoLightModel_BASE_COLOR
    PHONG = _coin.SoLightModel_PHONG
    model = _swig_property(_coin.SoLightModel_model_get, _coin.SoLightModel_model_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoLightModel_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoLightModel_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoLightModel_callback(self, *args)

SoLightModel_swigregister = _coin.SoLightModel_swigregister
SoLightModel_swigregister(SoLightModel)

def SoLightModel_getClassTypeId():
  """SoLightModel_getClassTypeId() -> SoType"""
  return _coin.SoLightModel_getClassTypeId()

def SoLightModel_initClass():
  """SoLightModel_initClass()"""
  return _coin.SoLightModel_initClass()

class SoMaterialBindingElement(SoInt32Element):
    """Proxy of C++ SoMaterialBindingElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMaterialBindingElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoMaterialBindingElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMaterialBindingElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoMaterialBindingElement_initClass()

    initClass = staticmethod(initClass)
    OVERALL = _coin.SoMaterialBindingElement_OVERALL
    PER_PART = _coin.SoMaterialBindingElement_PER_PART
    PER_PART_INDEXED = _coin.SoMaterialBindingElement_PER_PART_INDEXED
    PER_FACE = _coin.SoMaterialBindingElement_PER_FACE
    PER_FACE_INDEXED = _coin.SoMaterialBindingElement_PER_FACE_INDEXED
    PER_VERTEX = _coin.SoMaterialBindingElement_PER_VERTEX
    PER_VERTEX_INDEXED = _coin.SoMaterialBindingElement_PER_VERTEX_INDEXED
    DEFAULT = _coin.SoMaterialBindingElement_DEFAULT
    NONE = _coin.SoMaterialBindingElement_NONE
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoMaterialBindingElement_init(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, Binding binding)
        set(SoState state, Binding binding)
        """
        return _coin.SoMaterialBindingElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> Binding"""
        return _coin.SoMaterialBindingElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> Binding"""
        return _coin.SoMaterialBindingElement_getDefault()

    getDefault = staticmethod(getDefault)
SoMaterialBindingElement_swigregister = _coin.SoMaterialBindingElement_swigregister
SoMaterialBindingElement_swigregister(SoMaterialBindingElement)

def SoMaterialBindingElement_getClassTypeId():
  """SoMaterialBindingElement_getClassTypeId() -> SoType"""
  return _coin.SoMaterialBindingElement_getClassTypeId()

def SoMaterialBindingElement_getClassStackIndex():
  """SoMaterialBindingElement_getClassStackIndex() -> int"""
  return _coin.SoMaterialBindingElement_getClassStackIndex()

def SoMaterialBindingElement_createInstance():
  """SoMaterialBindingElement_createInstance() -> void"""
  return _coin.SoMaterialBindingElement_createInstance()

def SoMaterialBindingElement_initClass():
  """SoMaterialBindingElement_initClass()"""
  return _coin.SoMaterialBindingElement_initClass()

def SoMaterialBindingElement_set(*args):
  """
    set(SoState state, SoNode node, Binding binding)
    SoMaterialBindingElement_set(SoState state, Binding binding)
    """
  return _coin.SoMaterialBindingElement_set(*args)

def SoMaterialBindingElement_get(*args):
  """SoMaterialBindingElement_get(SoState state) -> Binding"""
  return _coin.SoMaterialBindingElement_get(*args)

def SoMaterialBindingElement_getDefault():
  """SoMaterialBindingElement_getDefault() -> Binding"""
  return _coin.SoMaterialBindingElement_getDefault()

class SoMaterialBinding(SoNode):
    """Proxy of C++ SoMaterialBinding class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMaterialBinding_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMaterialBinding_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoMaterialBinding_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoMaterialBinding"""
        this = _coin.new_SoMaterialBinding()
        try: self.this.append(this)
        except: self.this = this
    OVERALL = _coin.SoMaterialBinding_OVERALL
    PER_PART = _coin.SoMaterialBinding_PER_PART
    PER_PART_INDEXED = _coin.SoMaterialBinding_PER_PART_INDEXED
    PER_FACE = _coin.SoMaterialBinding_PER_FACE
    PER_FACE_INDEXED = _coin.SoMaterialBinding_PER_FACE_INDEXED
    PER_VERTEX = _coin.SoMaterialBinding_PER_VERTEX
    PER_VERTEX_INDEXED = _coin.SoMaterialBinding_PER_VERTEX_INDEXED
    DEFAULT = _coin.SoMaterialBinding_DEFAULT
    NONE = _coin.SoMaterialBinding_NONE
    value = _swig_property(_coin.SoMaterialBinding_value_get, _coin.SoMaterialBinding_value_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoMaterialBinding_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoMaterialBinding_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoMaterialBinding_callback(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoMaterialBinding_pick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoMaterialBinding_getPrimitiveCount(self, *args)

SoMaterialBinding_swigregister = _coin.SoMaterialBinding_swigregister
SoMaterialBinding_swigregister(SoMaterialBinding)

def SoMaterialBinding_getClassTypeId():
  """SoMaterialBinding_getClassTypeId() -> SoType"""
  return _coin.SoMaterialBinding_getClassTypeId()

def SoMaterialBinding_initClass():
  """SoMaterialBinding_initClass()"""
  return _coin.SoMaterialBinding_initClass()

class SoNormalBindingElement(SoInt32Element):
    """Proxy of C++ SoNormalBindingElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoNormalBindingElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoNormalBindingElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoNormalBindingElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoNormalBindingElement_initClass()

    initClass = staticmethod(initClass)
    OVERALL = _coin.SoNormalBindingElement_OVERALL
    PER_PART = _coin.SoNormalBindingElement_PER_PART
    PER_PART_INDEXED = _coin.SoNormalBindingElement_PER_PART_INDEXED
    PER_FACE = _coin.SoNormalBindingElement_PER_FACE
    PER_FACE_INDEXED = _coin.SoNormalBindingElement_PER_FACE_INDEXED
    PER_VERTEX = _coin.SoNormalBindingElement_PER_VERTEX
    PER_VERTEX_INDEXED = _coin.SoNormalBindingElement_PER_VERTEX_INDEXED
    DEFAULT = _coin.SoNormalBindingElement_DEFAULT
    NONE = _coin.SoNormalBindingElement_NONE
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoNormalBindingElement_init(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, Binding binding)
        set(SoState state, Binding binding)
        """
        return _coin.SoNormalBindingElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> Binding"""
        return _coin.SoNormalBindingElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> Binding"""
        return _coin.SoNormalBindingElement_getDefault()

    getDefault = staticmethod(getDefault)
SoNormalBindingElement_swigregister = _coin.SoNormalBindingElement_swigregister
SoNormalBindingElement_swigregister(SoNormalBindingElement)

def SoNormalBindingElement_getClassTypeId():
  """SoNormalBindingElement_getClassTypeId() -> SoType"""
  return _coin.SoNormalBindingElement_getClassTypeId()

def SoNormalBindingElement_getClassStackIndex():
  """SoNormalBindingElement_getClassStackIndex() -> int"""
  return _coin.SoNormalBindingElement_getClassStackIndex()

def SoNormalBindingElement_createInstance():
  """SoNormalBindingElement_createInstance() -> void"""
  return _coin.SoNormalBindingElement_createInstance()

def SoNormalBindingElement_initClass():
  """SoNormalBindingElement_initClass()"""
  return _coin.SoNormalBindingElement_initClass()

def SoNormalBindingElement_set(*args):
  """
    set(SoState state, SoNode node, Binding binding)
    SoNormalBindingElement_set(SoState state, Binding binding)
    """
  return _coin.SoNormalBindingElement_set(*args)

def SoNormalBindingElement_get(*args):
  """SoNormalBindingElement_get(SoState state) -> Binding"""
  return _coin.SoNormalBindingElement_get(*args)

def SoNormalBindingElement_getDefault():
  """SoNormalBindingElement_getDefault() -> Binding"""
  return _coin.SoNormalBindingElement_getDefault()

class SoNormalBinding(SoNode):
    """Proxy of C++ SoNormalBinding class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoNormalBinding_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoNormalBinding_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoNormalBinding_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoNormalBinding"""
        this = _coin.new_SoNormalBinding()
        try: self.this.append(this)
        except: self.this = this
    OVERALL = _coin.SoNormalBinding_OVERALL
    PER_PART = _coin.SoNormalBinding_PER_PART
    PER_PART_INDEXED = _coin.SoNormalBinding_PER_PART_INDEXED
    PER_FACE = _coin.SoNormalBinding_PER_FACE
    PER_FACE_INDEXED = _coin.SoNormalBinding_PER_FACE_INDEXED
    PER_VERTEX = _coin.SoNormalBinding_PER_VERTEX
    PER_VERTEX_INDEXED = _coin.SoNormalBinding_PER_VERTEX_INDEXED
    DEFAULT = _coin.SoNormalBinding_DEFAULT
    NONE = _coin.SoNormalBinding_NONE
    value = _swig_property(_coin.SoNormalBinding_value_get, _coin.SoNormalBinding_value_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoNormalBinding_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoNormalBinding_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoNormalBinding_callback(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoNormalBinding_pick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoNormalBinding_getPrimitiveCount(self, *args)

SoNormalBinding_swigregister = _coin.SoNormalBinding_swigregister
SoNormalBinding_swigregister(SoNormalBinding)

def SoNormalBinding_getClassTypeId():
  """SoNormalBinding_getClassTypeId() -> SoType"""
  return _coin.SoNormalBinding_getClassTypeId()

def SoNormalBinding_initClass():
  """SoNormalBinding_initClass()"""
  return _coin.SoNormalBinding_initClass()

class SoPickStyleElement(SoInt32Element):
    """Proxy of C++ SoPickStyleElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoPickStyleElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoPickStyleElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoPickStyleElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoPickStyleElement_initClass()

    initClass = staticmethod(initClass)
    SHAPE = _coin.SoPickStyleElement_SHAPE
    BOUNDING_BOX = _coin.SoPickStyleElement_BOUNDING_BOX
    UNPICKABLE = _coin.SoPickStyleElement_UNPICKABLE
    SHAPE_ON_TOP = _coin.SoPickStyleElement_SHAPE_ON_TOP
    BOUNDING_BOX_ON_TOP = _coin.SoPickStyleElement_BOUNDING_BOX_ON_TOP
    SHAPE_FRONTFACES = _coin.SoPickStyleElement_SHAPE_FRONTFACES
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoPickStyleElement_init(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, int32_t style)
        set(SoState state, Style style)
        """
        return _coin.SoPickStyleElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> Style"""
        return _coin.SoPickStyleElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> Style"""
        return _coin.SoPickStyleElement_getDefault()

    getDefault = staticmethod(getDefault)
SoPickStyleElement_swigregister = _coin.SoPickStyleElement_swigregister
SoPickStyleElement_swigregister(SoPickStyleElement)

def SoPickStyleElement_getClassTypeId():
  """SoPickStyleElement_getClassTypeId() -> SoType"""
  return _coin.SoPickStyleElement_getClassTypeId()

def SoPickStyleElement_getClassStackIndex():
  """SoPickStyleElement_getClassStackIndex() -> int"""
  return _coin.SoPickStyleElement_getClassStackIndex()

def SoPickStyleElement_createInstance():
  """SoPickStyleElement_createInstance() -> void"""
  return _coin.SoPickStyleElement_createInstance()

def SoPickStyleElement_initClass():
  """SoPickStyleElement_initClass()"""
  return _coin.SoPickStyleElement_initClass()

def SoPickStyleElement_set(*args):
  """
    set(SoState state, SoNode node, int32_t style)
    SoPickStyleElement_set(SoState state, Style style)
    """
  return _coin.SoPickStyleElement_set(*args)

def SoPickStyleElement_get(*args):
  """SoPickStyleElement_get(SoState state) -> Style"""
  return _coin.SoPickStyleElement_get(*args)

def SoPickStyleElement_getDefault():
  """SoPickStyleElement_getDefault() -> Style"""
  return _coin.SoPickStyleElement_getDefault()

class SoPickStyle(SoNode):
    """Proxy of C++ SoPickStyle class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoPickStyle_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoPickStyle_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoPickStyle_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoPickStyle"""
        this = _coin.new_SoPickStyle()
        try: self.this.append(this)
        except: self.this = this
    SHAPE = _coin.SoPickStyle_SHAPE
    BOUNDING_BOX = _coin.SoPickStyle_BOUNDING_BOX
    UNPICKABLE = _coin.SoPickStyle_UNPICKABLE
    SHAPE_ON_TOP = _coin.SoPickStyle_SHAPE_ON_TOP
    BOUNDING_BOX_ON_TOP = _coin.SoPickStyle_BOUNDING_BOX_ON_TOP
    SHAPE_FRONTFACES = _coin.SoPickStyle_SHAPE_FRONTFACES
    style = _swig_property(_coin.SoPickStyle_style_get, _coin.SoPickStyle_style_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoPickStyle_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoPickStyle_callback(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoPickStyle_pick(self, *args)

SoPickStyle_swigregister = _coin.SoPickStyle_swigregister
SoPickStyle_swigregister(SoPickStyle)

def SoPickStyle_getClassTypeId():
  """SoPickStyle_getClassTypeId() -> SoType"""
  return _coin.SoPickStyle_getClassTypeId()

def SoPickStyle_initClass():
  """SoPickStyle_initClass()"""
  return _coin.SoPickStyle_initClass()

class SoShapeHintsElement(SoElement):
    """Proxy of C++ SoShapeHintsElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShapeHintsElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoShapeHintsElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoShapeHintsElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoShapeHintsElement_initClass()

    initClass = staticmethod(initClass)
    UNKNOWN_ORDERING = _coin.SoShapeHintsElement_UNKNOWN_ORDERING
    CLOCKWISE = _coin.SoShapeHintsElement_CLOCKWISE
    COUNTERCLOCKWISE = _coin.SoShapeHintsElement_COUNTERCLOCKWISE
    ORDERING_AS_IS = _coin.SoShapeHintsElement_ORDERING_AS_IS
    UNKNOWN_SHAPE_TYPE = _coin.SoShapeHintsElement_UNKNOWN_SHAPE_TYPE
    SOLID = _coin.SoShapeHintsElement_SOLID
    SHAPE_TYPE_AS_IS = _coin.SoShapeHintsElement_SHAPE_TYPE_AS_IS
    UNKNOWN_FACE_TYPE = _coin.SoShapeHintsElement_UNKNOWN_FACE_TYPE
    CONVEX = _coin.SoShapeHintsElement_CONVEX
    FACE_TYPE_AS_IS = _coin.SoShapeHintsElement_FACE_TYPE_AS_IS
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoShapeHintsElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoShapeHintsElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevtopelement)"""
        return _coin.SoShapeHintsElement_pop(self, *args)

    def matches(self, *args):
        """matches(self, SoElement element) -> SbBool"""
        return _coin.SoShapeHintsElement_matches(self, *args)

    def copyMatchInfo(self):
        """copyMatchInfo(self) -> SoElement"""
        return _coin.SoShapeHintsElement_copyMatchInfo(self)

    def set(*args):
        """
        set(SoState state, SoNode node, VertexOrdering vertexOrdering, 
            ShapeType shapeType, FaceType faceType)
        set(SoState state, VertexOrdering vertexOrdering, ShapeType shapeType, 
            FaceType faceType)
        """
        return _coin.SoShapeHintsElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """
        get(SoState state, VertexOrdering vertexOrdering, ShapeType shapeType, 
            FaceType faceType)
        """
        return _coin.SoShapeHintsElement_get(*args)

    get = staticmethod(get)
    def getVertexOrdering(*args):
        """getVertexOrdering(SoState state) -> VertexOrdering"""
        return _coin.SoShapeHintsElement_getVertexOrdering(*args)

    getVertexOrdering = staticmethod(getVertexOrdering)
    def getShapeType(*args):
        """getShapeType(SoState state) -> ShapeType"""
        return _coin.SoShapeHintsElement_getShapeType(*args)

    getShapeType = staticmethod(getShapeType)
    def getFaceType(*args):
        """getFaceType(SoState state) -> FaceType"""
        return _coin.SoShapeHintsElement_getFaceType(*args)

    getFaceType = staticmethod(getFaceType)
    def getDefaultVertexOrdering():
        """getDefaultVertexOrdering() -> VertexOrdering"""
        return _coin.SoShapeHintsElement_getDefaultVertexOrdering()

    getDefaultVertexOrdering = staticmethod(getDefaultVertexOrdering)
    def getDefaultShapeType():
        """getDefaultShapeType() -> ShapeType"""
        return _coin.SoShapeHintsElement_getDefaultShapeType()

    getDefaultShapeType = staticmethod(getDefaultShapeType)
    def getDefaultFaceType():
        """getDefaultFaceType() -> FaceType"""
        return _coin.SoShapeHintsElement_getDefaultFaceType()

    getDefaultFaceType = staticmethod(getDefaultFaceType)
    def output(self, *args):
        """output(self, FILE file)"""
        return _coin.SoShapeHintsElement_output(self, *args)

SoShapeHintsElement_swigregister = _coin.SoShapeHintsElement_swigregister
SoShapeHintsElement_swigregister(SoShapeHintsElement)

def SoShapeHintsElement_getClassTypeId():
  """SoShapeHintsElement_getClassTypeId() -> SoType"""
  return _coin.SoShapeHintsElement_getClassTypeId()

def SoShapeHintsElement_getClassStackIndex():
  """SoShapeHintsElement_getClassStackIndex() -> int"""
  return _coin.SoShapeHintsElement_getClassStackIndex()

def SoShapeHintsElement_createInstance():
  """SoShapeHintsElement_createInstance() -> void"""
  return _coin.SoShapeHintsElement_createInstance()

def SoShapeHintsElement_initClass():
  """SoShapeHintsElement_initClass()"""
  return _coin.SoShapeHintsElement_initClass()

def SoShapeHintsElement_set(*args):
  """
    set(SoState state, SoNode node, VertexOrdering vertexOrdering, 
        ShapeType shapeType, FaceType faceType)
    SoShapeHintsElement_set(SoState state, VertexOrdering vertexOrdering, ShapeType shapeType, 
        FaceType faceType)
    """
  return _coin.SoShapeHintsElement_set(*args)

def SoShapeHintsElement_get(*args):
  """
    SoShapeHintsElement_get(SoState state, VertexOrdering vertexOrdering, ShapeType shapeType, 
        FaceType faceType)
    """
  return _coin.SoShapeHintsElement_get(*args)

def SoShapeHintsElement_getVertexOrdering(*args):
  """SoShapeHintsElement_getVertexOrdering(SoState state) -> VertexOrdering"""
  return _coin.SoShapeHintsElement_getVertexOrdering(*args)

def SoShapeHintsElement_getShapeType(*args):
  """SoShapeHintsElement_getShapeType(SoState state) -> ShapeType"""
  return _coin.SoShapeHintsElement_getShapeType(*args)

def SoShapeHintsElement_getFaceType(*args):
  """SoShapeHintsElement_getFaceType(SoState state) -> FaceType"""
  return _coin.SoShapeHintsElement_getFaceType(*args)

def SoShapeHintsElement_getDefaultVertexOrdering():
  """SoShapeHintsElement_getDefaultVertexOrdering() -> VertexOrdering"""
  return _coin.SoShapeHintsElement_getDefaultVertexOrdering()

def SoShapeHintsElement_getDefaultShapeType():
  """SoShapeHintsElement_getDefaultShapeType() -> ShapeType"""
  return _coin.SoShapeHintsElement_getDefaultShapeType()

def SoShapeHintsElement_getDefaultFaceType():
  """SoShapeHintsElement_getDefaultFaceType() -> FaceType"""
  return _coin.SoShapeHintsElement_getDefaultFaceType()

class SoSFBool(SoSField):
    """Proxy of C++ SoSFBool class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFBool"""
        this = _coin.new_SoSFBool()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFBool
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFBool_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFBool_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFBool_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFBool_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFBool_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SbBool"""
        return _coin.SoSFBool_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFBool field) -> int"""
        return _coin.SoSFBool___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFBool field) -> int"""
        return _coin.SoSFBool___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFBool_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbBool newvalue)
        setValue(self, SoSFBool other)
        """
        return _coin.SoSFBool_setValue(self, *args)

SoSFBool_swigregister = _coin.SoSFBool_swigregister
SoSFBool_swigregister(SoSFBool)

def SoSFBool_createInstance():
  """SoSFBool_createInstance() -> void"""
  return _coin.SoSFBool_createInstance()

def SoSFBool_getClassTypeId():
  """SoSFBool_getClassTypeId() -> SoType"""
  return _coin.SoSFBool_getClassTypeId()

def SoSFBool_initClass():
  """SoSFBool_initClass()"""
  return _coin.SoSFBool_initClass()

class SoShapeHints(SoNode):
    """Proxy of C++ SoShapeHints class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShapeHints_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoShapeHints_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoShapeHints_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoShapeHints"""
        this = _coin.new_SoShapeHints()
        try: self.this.append(this)
        except: self.this = this
    UNKNOWN_ORDERING = _coin.SoShapeHints_UNKNOWN_ORDERING
    CLOCKWISE = _coin.SoShapeHints_CLOCKWISE
    COUNTERCLOCKWISE = _coin.SoShapeHints_COUNTERCLOCKWISE
    UNKNOWN_SHAPE_TYPE = _coin.SoShapeHints_UNKNOWN_SHAPE_TYPE
    SOLID = _coin.SoShapeHints_SOLID
    UNKNOWN_FACE_TYPE = _coin.SoShapeHints_UNKNOWN_FACE_TYPE
    CONVEX = _coin.SoShapeHints_CONVEX
    NO_WINDING_TYPE = _coin.SoShapeHints_NO_WINDING_TYPE
    vertexOrdering = _swig_property(_coin.SoShapeHints_vertexOrdering_get, _coin.SoShapeHints_vertexOrdering_set)
    shapeType = _swig_property(_coin.SoShapeHints_shapeType_get, _coin.SoShapeHints_shapeType_set)
    faceType = _swig_property(_coin.SoShapeHints_faceType_get, _coin.SoShapeHints_faceType_set)
    windingType = _swig_property(_coin.SoShapeHints_windingType_get, _coin.SoShapeHints_windingType_set)
    useVBO = _swig_property(_coin.SoShapeHints_useVBO_get, _coin.SoShapeHints_useVBO_set)
    creaseAngle = _swig_property(_coin.SoShapeHints_creaseAngle_get, _coin.SoShapeHints_creaseAngle_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoShapeHints_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoShapeHints_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoShapeHints_callback(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoShapeHints_getBoundingBox(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoShapeHints_pick(self, *args)

SoShapeHints_swigregister = _coin.SoShapeHints_swigregister
SoShapeHints_swigregister(SoShapeHints)

def SoShapeHints_getClassTypeId():
  """SoShapeHints_getClassTypeId() -> SoType"""
  return _coin.SoShapeHints_getClassTypeId()

def SoShapeHints_initClass():
  """SoShapeHints_initClass()"""
  return _coin.SoShapeHints_initClass()

class SoTexture(SoNode):
    """Proxy of C++ SoTexture class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTexture_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTexture_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTexture_initClass()

    initClass = staticmethod(initClass)
    def cleanupClass():
        """cleanupClass()"""
        return _coin.SoTexture_cleanupClass()

    cleanupClass = staticmethod(cleanupClass)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoTexture_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoTexture_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoTexture_callback(self, *args)

SoTexture_swigregister = _coin.SoTexture_swigregister
SoTexture_swigregister(SoTexture)

def SoTexture_getClassTypeId():
  """SoTexture_getClassTypeId() -> SoType"""
  return _coin.SoTexture_getClassTypeId()

def SoTexture_initClass():
  """SoTexture_initClass()"""
  return _coin.SoTexture_initClass()

def SoTexture_cleanupClass():
  """SoTexture_cleanupClass()"""
  return _coin.SoTexture_cleanupClass()

class SoSFImage(SoSField):
    """Proxy of C++ SoSFImage class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFImage"""
        this = _coin.new_SoSFImage()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFImage
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFImage_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFImage_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFImage_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFImage_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFImage_isSame(self, *args)

    COPY = _coin.SoSFImage_COPY
    NO_COPY = _coin.SoSFImage_NO_COPY
    NO_COPY_AND_DELETE = _coin.SoSFImage_NO_COPY_AND_DELETE
    NO_COPY_AND_FREE = _coin.SoSFImage_NO_COPY_AND_FREE
    def initClass():
        """initClass()"""
        return _coin.SoSFImage_initClass()

    initClass = staticmethod(initClass)
    def getValue(self, *args):
        """
        getValue(self) -> unsigned char
        getValue(self) -> SbImage
        """
        return _coin.SoSFImage_getValue(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoSFImage field) -> int"""
        return _coin.SoSFImage___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFImage field) -> int"""
        return _coin.SoSFImage___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> unsigned char"""
        return _coin.SoSFImage_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoSFImage_finishEditing(self)

    def setSubValue(self, *args):
        """setSubValue(self, SbVec2s dims, SbVec2s offset, unsigned char pixels)"""
        return _coin.SoSFImage_setSubValue(self, *args)

    def setSubValues(self, *args):
        """setSubValues(self, SbVec2s dims, SbVec2s offsets, int num, unsigned char pixelblocks)"""
        return _coin.SoSFImage_setSubValues(self, *args)

    def getSubTexture(self, *args):
        """getSubTexture(self, int idx, SbVec2s dims, SbVec2s offset) -> unsigned char"""
        return _coin.SoSFImage_getSubTexture(self, *args)

    def hasSubTextures(self, *args):
        """hasSubTextures(self, int numsubtextures) -> SbBool"""
        return _coin.SoSFImage_hasSubTextures(self, *args)

    def setNeverWrite(self, *args):
        """setNeverWrite(self, SbBool flag)"""
        return _coin.SoSFImage_setNeverWrite(self, *args)

    def isNeverWrite(self):
        """isNeverWrite(self) -> SbBool"""
        return _coin.SoSFImage_isNeverWrite(self)

    def hasTransparency(self):
        """hasTransparency(self) -> SbBool"""
        return _coin.SoSFImage_hasTransparency(self)

    def setValue(self, *args):
        """
        setValue(self, SbVec2s size, int nc, unsigned char pixels, CopyPolicy copypolicy = COPY)
        setValue(self, SbVec2s size, int nc, unsigned char pixels)
        setValue(self, SbVec2s size, int nc, PyObject pixels)
        setValue(self, SoSFImage other)
        """
        return _coin.SoSFImage_setValue(self, *args)

SoSFImage_swigregister = _coin.SoSFImage_swigregister
SoSFImage_swigregister(SoSFImage)

def SoSFImage_createInstance():
  """SoSFImage_createInstance() -> void"""
  return _coin.SoSFImage_createInstance()

def SoSFImage_getClassTypeId():
  """SoSFImage_getClassTypeId() -> SoType"""
  return _coin.SoSFImage_getClassTypeId()

def SoSFImage_initClass():
  """SoSFImage_initClass()"""
  return _coin.SoSFImage_initClass()

class SoSFString(SoSField):
    """Proxy of C++ SoSFString class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFString"""
        this = _coin.new_SoSFString()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFString
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFString_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFString_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFString_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFString_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFString_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SbString"""
        return _coin.SoSFString_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFString field) -> int"""
        return _coin.SoSFString___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFString field) -> int"""
        return _coin.SoSFString___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFString_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbString newvalue)
        setValue(self, char str)
        setValue(self, SoSFString other)
        """
        return _coin.SoSFString_setValue(self, *args)

SoSFString_swigregister = _coin.SoSFString_swigregister
SoSFString_swigregister(SoSFString)

def SoSFString_createInstance():
  """SoSFString_createInstance() -> void"""
  return _coin.SoSFString_createInstance()

def SoSFString_getClassTypeId():
  """SoSFString_getClassTypeId() -> SoType"""
  return _coin.SoSFString_getClassTypeId()

def SoSFString_initClass():
  """SoSFString_initClass()"""
  return _coin.SoSFString_initClass()

class SoSFColor(SoSField):
    """Proxy of C++ SoSFColor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFColor"""
        this = _coin.new_SoSFColor()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFColor
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFColor_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFColor_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFColor_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFColor_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFColor_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SbColor"""
        return _coin.SoSFColor_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFColor field) -> int"""
        return _coin.SoSFColor___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFColor field) -> int"""
        return _coin.SoSFColor___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFColor_initClass()

    initClass = staticmethod(initClass)
    def setHSVValue(self, *args):
        """
        setHSVValue(self, float h, float s, float v)
        setHSVValue(self, float hsv)
        """
        return _coin.SoSFColor_setHSVValue(self, *args)

    def setValue(self, *args):
        """
        setValue(self, SbColor newvalue)
        setValue(self, SbVec3f vec)
        setValue(self, float red, float green, float blue)
        setValue(self, float rgb)
        setValue(self, SoSFColor other)
        """
        return _coin.SoSFColor_setValue(self, *args)

SoSFColor_swigregister = _coin.SoSFColor_swigregister
SoSFColor_swigregister(SoSFColor)

def SoSFColor_createInstance():
  """SoSFColor_createInstance() -> void"""
  return _coin.SoSFColor_createInstance()

def SoSFColor_getClassTypeId():
  """SoSFColor_getClassTypeId() -> SoType"""
  return _coin.SoSFColor_getClassTypeId()

def SoSFColor_initClass():
  """SoSFColor_initClass()"""
  return _coin.SoSFColor_initClass()

class SoReplacedElement(SoElement):
    """Proxy of C++ SoReplacedElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoReplacedElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoReplacedElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def initClass():
        """initClass()"""
        return _coin.SoReplacedElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoReplacedElement_init(self, *args)

    def matches(self, *args):
        """matches(self, SoElement element) -> SbBool"""
        return _coin.SoReplacedElement_matches(self, *args)

    def copyMatchInfo(self):
        """copyMatchInfo(self) -> SoElement"""
        return _coin.SoReplacedElement_copyMatchInfo(self)

    def getNodeId(self):
        """getNodeId(self) -> uint32_t"""
        return _coin.SoReplacedElement_getNodeId(self)

    def output(self, *args):
        """output(self, FILE file)"""
        return _coin.SoReplacedElement_output(self, *args)

SoReplacedElement_swigregister = _coin.SoReplacedElement_swigregister
SoReplacedElement_swigregister(SoReplacedElement)

def SoReplacedElement_getClassTypeId():
  """SoReplacedElement_getClassTypeId() -> SoType"""
  return _coin.SoReplacedElement_getClassTypeId()

def SoReplacedElement_getClassStackIndex():
  """SoReplacedElement_getClassStackIndex() -> int"""
  return _coin.SoReplacedElement_getClassStackIndex()

def SoReplacedElement_initClass():
  """SoReplacedElement_initClass()"""
  return _coin.SoReplacedElement_initClass()

class SbVec3s(object):
    """Proxy of C++ SbVec3s class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbVec3s
        __init__(self, short v) -> SbVec3s
        __init__(self, short x, short y, short z) -> SbVec3s
        __init__(self, SbVec3us v) -> SbVec3s
        __init__(self, SbVec3b v) -> SbVec3s
        __init__(self, SbVec3i32 v) -> SbVec3s
        __init__(self, SbVec3f v) -> SbVec3s
        __init__(self, SbVec3d v) -> SbVec3s
        """
        this = _coin.new_SbVec3s(*args)
        try: self.this.append(this)
        except: self.this = this
    def setValue(self, *args):
        """
        setValue(self, short v) -> SbVec3s
        setValue(self, short x, short y, short z) -> SbVec3s
        setValue(self, SbVec3us v) -> SbVec3s
        setValue(self, SbVec3b v) -> SbVec3s
        setValue(self, SbVec3i32 v) -> SbVec3s
        setValue(self, SbVec3f v) -> SbVec3s
        setValue(self, SbVec3d v) -> SbVec3s
        """
        return _coin.SbVec3s_setValue(self, *args)

    def getValue(self, *args):
        """
        getValue(self) -> short
        getValue(self)
        """
        return _coin.SbVec3s_getValue(self, *args)

    def dot(self, *args):
        """dot(self, SbVec3s v) -> int32_t"""
        return _coin.SbVec3s_dot(self, *args)

    def negate(self):
        """negate(self)"""
        return _coin.SbVec3s_negate(self)

    def __imul__(self, *args):
        """
        __imul__(self, int d) -> SbVec3s
        __imul__(self, double d) -> SbVec3s
        """
        return _coin.SbVec3s___imul__(self, *args)

    def __idiv__(self, *args):
        """
        __idiv__(self, int d) -> SbVec3s
        __idiv__(self, double d) -> SbVec3s
        """
        return _coin.SbVec3s___idiv__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, SbVec3s v) -> SbVec3s"""
        return _coin.SbVec3s___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, SbVec3s v) -> SbVec3s"""
        return _coin.SbVec3s___isub__(self, *args)

    def __neg__(self):
        """__neg__(self) -> SbVec3s"""
        return _coin.SbVec3s___neg__(self)

    def output(self, *args):
        """output(self, FILE fp)"""
        return _coin.SbVec3s_output(self, *args)

    def __add__(self, *args):
        """__add__(self, SbVec3s u) -> SbVec3s"""
        return _coin.SbVec3s___add__(self, *args)

    def __sub__(self, *args):
        """__sub__(self, SbVec3s u) -> SbVec3s"""
        return _coin.SbVec3s___sub__(self, *args)

    def __mul__(self, *args):
        """__mul__(self, double d) -> SbVec3s"""
        return _coin.SbVec3s___mul__(self, *args)

    def __rmul__(self, *args):
        """__rmul__(self, double d) -> SbVec3s"""
        return _coin.SbVec3s___rmul__(self, *args)

    def __div__(self, *args):
        """__div__(self, double d) -> SbVec3s"""
        return _coin.SbVec3s___div__(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SbVec3s u) -> int"""
        return _coin.SbVec3s___eq__(self, *args)

    def __nq__(self, *args):
        """__nq__(self, SbVec3s u) -> int"""
        return _coin.SbVec3s___nq__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> short"""
        return _coin.SbVec3s___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, short value)"""
        return _coin.SbVec3s___setitem__(self, *args)

    def __iter__(self):
       for i in range(3):
          yield self[i]
       
    def __len__(self):
          return 3

    __swig_destroy__ = _coin.delete_SbVec3s
    __del__ = lambda self : None;
SbVec3s_swigregister = _coin.SbVec3s_swigregister
SbVec3s_swigregister(SbVec3s)

class SoTextureImageElement(SoReplacedElement):
    """Proxy of C++ SoTextureImageElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextureImageElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoTextureImageElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoTextureImageElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoTextureImageElement_initClass()

    initClass = staticmethod(initClass)
    BLEND = _coin.SoTextureImageElement_BLEND
    MODULATE = _coin.SoTextureImageElement_MODULATE
    DECAL = _coin.SoTextureImageElement_DECAL
    REPLACE = _coin.SoTextureImageElement_REPLACE
    CLAMP = _coin.SoTextureImageElement_CLAMP
    REPEAT = _coin.SoTextureImageElement_REPEAT
    CLAMP_TO_BORDER = _coin.SoTextureImageElement_CLAMP_TO_BORDER
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoTextureImageElement_init(self, *args)

    def setDefault(*args):
        """setDefault(SoState state, SoNode node)"""
        return _coin.SoTextureImageElement_setDefault(*args)

    setDefault = staticmethod(setDefault)
    def set(*args):
        """
        set(SoState state, SoNode node, SbVec2s size, int numComponents, 
            unsigned char bytes, int wrapS, int wrapT, 
            int model, SbColor blendColor)
        set(SoState state, SoNode node, SbVec3s size, int numComponents, 
            unsigned char bytes, int wrapS, int wrapT, 
            int wrapR, int model, SbColor blendColor)
        set(SoState state, SoNode node, SbVec2s size, int numComponents, 
            unsigned char bytes, Wrap wrapS, Wrap wrapT, 
            Model model, SbColor blendColor)
        set(SoState state, SoNode node, SbVec3s size, int numComponents, 
            unsigned char bytes, Wrap wrapS, Wrap wrapT, 
            Wrap wrapR, Model model, SbColor blendColor)
        """
        return _coin.SoTextureImageElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """
        get(SoState state, SbVec2s size, int numComponents, Wrap wrapS, 
            Wrap wrapT, Model model, SbColor blendColor) -> unsigned char
        get(SoState state, SbVec3s size, int numComponents, Wrap wrapS, 
            Wrap wrapT, Wrap wrapR, Model model, 
            SbColor blendColor) -> unsigned char
        get(SoState state, SbVec2s size, int numComponents, int wrapS, 
            int wrapT, int model, SbColor blendColor) -> unsigned char
        get(SoState state, SbVec3s size, int numComponents, int wrapS, 
            int wrapT, int wrapR, int model, SbColor blendColor) -> unsigned char
        """
        return _coin.SoTextureImageElement_get(*args)

    get = staticmethod(get)
    def getBlendColor(*args):
        """getBlendColor(SoState state) -> SbColor"""
        return _coin.SoTextureImageElement_getBlendColor(*args)

    getBlendColor = staticmethod(getBlendColor)
    def getImage(*args):
        """
        getImage(SoState state, SbVec2s size, int numComponents) -> unsigned char
        getImage(SoState state, SbVec3s size, int numComponents) -> unsigned char
        """
        return _coin.SoTextureImageElement_getImage(*args)

    getImage = staticmethod(getImage)
    def getModel(*args):
        """getModel(SoState state) -> Model"""
        return _coin.SoTextureImageElement_getModel(*args)

    getModel = staticmethod(getModel)
    def getWrapS(*args):
        """getWrapS(SoState state) -> Wrap"""
        return _coin.SoTextureImageElement_getWrapS(*args)

    getWrapS = staticmethod(getWrapS)
    def getWrapT(*args):
        """getWrapT(SoState state) -> Wrap"""
        return _coin.SoTextureImageElement_getWrapT(*args)

    getWrapT = staticmethod(getWrapT)
    def getWrapR(*args):
        """getWrapR(SoState state) -> Wrap"""
        return _coin.SoTextureImageElement_getWrapR(*args)

    getWrapR = staticmethod(getWrapR)
    def containsTransparency(*args):
        """containsTransparency(SoState state) -> SbBool"""
        return _coin.SoTextureImageElement_containsTransparency(*args)

    containsTransparency = staticmethod(containsTransparency)
    def getDefault(*args):
        """
        getDefault(SbVec2s size, int numComponents) -> unsigned char
        getDefault(SbVec3s size, int numComponents) -> unsigned char
        """
        return _coin.SoTextureImageElement_getDefault(*args)

    getDefault = staticmethod(getDefault)
SoTextureImageElement_swigregister = _coin.SoTextureImageElement_swigregister
SoTextureImageElement_swigregister(SoTextureImageElement)

def SoTextureImageElement_getClassTypeId():
  """SoTextureImageElement_getClassTypeId() -> SoType"""
  return _coin.SoTextureImageElement_getClassTypeId()

def SoTextureImageElement_getClassStackIndex():
  """SoTextureImageElement_getClassStackIndex() -> int"""
  return _coin.SoTextureImageElement_getClassStackIndex()

def SoTextureImageElement_createInstance():
  """SoTextureImageElement_createInstance() -> void"""
  return _coin.SoTextureImageElement_createInstance()

def SoTextureImageElement_initClass():
  """SoTextureImageElement_initClass()"""
  return _coin.SoTextureImageElement_initClass()

def SoTextureImageElement_setDefault(*args):
  """SoTextureImageElement_setDefault(SoState state, SoNode node)"""
  return _coin.SoTextureImageElement_setDefault(*args)

def SoTextureImageElement_set(*args):
  """
    set(SoState state, SoNode node, SbVec2s size, int numComponents, 
        unsigned char bytes, int wrapS, int wrapT, 
        int model, SbColor blendColor)
    set(SoState state, SoNode node, SbVec3s size, int numComponents, 
        unsigned char bytes, int wrapS, int wrapT, 
        int wrapR, int model, SbColor blendColor)
    set(SoState state, SoNode node, SbVec2s size, int numComponents, 
        unsigned char bytes, Wrap wrapS, Wrap wrapT, 
        Model model, SbColor blendColor)
    SoTextureImageElement_set(SoState state, SoNode node, SbVec3s size, int numComponents, 
        unsigned char bytes, Wrap wrapS, Wrap wrapT, 
        Wrap wrapR, Model model, SbColor blendColor)
    """
  return _coin.SoTextureImageElement_set(*args)

def SoTextureImageElement_get(*args):
  """
    get(SoState state, SbVec2s size, int numComponents, Wrap wrapS, 
        Wrap wrapT, Model model, SbColor blendColor) -> unsigned char
    get(SoState state, SbVec3s size, int numComponents, Wrap wrapS, 
        Wrap wrapT, Wrap wrapR, Model model, 
        SbColor blendColor) -> unsigned char
    get(SoState state, SbVec2s size, int numComponents, int wrapS, 
        int wrapT, int model, SbColor blendColor) -> unsigned char
    SoTextureImageElement_get(SoState state, SbVec3s size, int numComponents, int wrapS, 
        int wrapT, int wrapR, int model, SbColor blendColor) -> unsigned char
    """
  return _coin.SoTextureImageElement_get(*args)

def SoTextureImageElement_getBlendColor(*args):
  """SoTextureImageElement_getBlendColor(SoState state) -> SbColor"""
  return _coin.SoTextureImageElement_getBlendColor(*args)

def SoTextureImageElement_getImage(*args):
  """
    getImage(SoState state, SbVec2s size, int numComponents) -> unsigned char
    SoTextureImageElement_getImage(SoState state, SbVec3s size, int numComponents) -> unsigned char
    """
  return _coin.SoTextureImageElement_getImage(*args)

def SoTextureImageElement_getModel(*args):
  """SoTextureImageElement_getModel(SoState state) -> Model"""
  return _coin.SoTextureImageElement_getModel(*args)

def SoTextureImageElement_getWrapS(*args):
  """SoTextureImageElement_getWrapS(SoState state) -> Wrap"""
  return _coin.SoTextureImageElement_getWrapS(*args)

def SoTextureImageElement_getWrapT(*args):
  """SoTextureImageElement_getWrapT(SoState state) -> Wrap"""
  return _coin.SoTextureImageElement_getWrapT(*args)

def SoTextureImageElement_getWrapR(*args):
  """SoTextureImageElement_getWrapR(SoState state) -> Wrap"""
  return _coin.SoTextureImageElement_getWrapR(*args)

def SoTextureImageElement_containsTransparency(*args):
  """SoTextureImageElement_containsTransparency(SoState state) -> SbBool"""
  return _coin.SoTextureImageElement_containsTransparency(*args)

def SoTextureImageElement_getDefault(*args):
  """
    getDefault(SbVec2s size, int numComponents) -> unsigned char
    SoTextureImageElement_getDefault(SbVec3s size, int numComponents) -> unsigned char
    """
  return _coin.SoTextureImageElement_getDefault(*args)

class SoTexture2(SoTexture):
    """Proxy of C++ SoTexture2 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTexture2_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTexture2_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTexture2_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTexture2"""
        this = _coin.new_SoTexture2()
        try: self.this.append(this)
        except: self.this = this
    MODULATE = _coin.SoTexture2_MODULATE
    DECAL = _coin.SoTexture2_DECAL
    BLEND = _coin.SoTexture2_BLEND
    REPLACE = _coin.SoTexture2_REPLACE
    REPEAT = _coin.SoTexture2_REPEAT
    CLAMP = _coin.SoTexture2_CLAMP
    filename = _swig_property(_coin.SoTexture2_filename_get, _coin.SoTexture2_filename_set)
    image = _swig_property(_coin.SoTexture2_image_get, _coin.SoTexture2_image_set)
    wrapS = _swig_property(_coin.SoTexture2_wrapS_get, _coin.SoTexture2_wrapS_set)
    wrapT = _swig_property(_coin.SoTexture2_wrapT_get, _coin.SoTexture2_wrapT_set)
    model = _swig_property(_coin.SoTexture2_model_get, _coin.SoTexture2_model_set)
    blendColor = _swig_property(_coin.SoTexture2_blendColor_get, _coin.SoTexture2_blendColor_set)
    enableCompressedTexture = _swig_property(_coin.SoTexture2_enableCompressedTexture_get, _coin.SoTexture2_enableCompressedTexture_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoTexture2_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoTexture2_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoTexture2_callback(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoTexture2_rayPick(self, *args)

    def readImage(*args):
        """readImage(SbString fname, int w, int h, int nc, unsigned char bytes) -> SbBool"""
        return _coin.SoTexture2_readImage(*args)

    readImage = staticmethod(readImage)
SoTexture2_swigregister = _coin.SoTexture2_swigregister
SoTexture2_swigregister(SoTexture2)

def SoTexture2_getClassTypeId():
  """SoTexture2_getClassTypeId() -> SoType"""
  return _coin.SoTexture2_getClassTypeId()

def SoTexture2_initClass():
  """SoTexture2_initClass()"""
  return _coin.SoTexture2_initClass()

def SoTexture2_readImage(*args):
  """SoTexture2_readImage(SbString fname, int w, int h, int nc, unsigned char bytes) -> SbBool"""
  return _coin.SoTexture2_readImage(*args)

class SoTextureCoordinateBindingElement(SoInt32Element):
    """Proxy of C++ SoTextureCoordinateBindingElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateBindingElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoTextureCoordinateBindingElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoTextureCoordinateBindingElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoTextureCoordinateBindingElement_initClass()

    initClass = staticmethod(initClass)
    PER_VERTEX = _coin.SoTextureCoordinateBindingElement_PER_VERTEX
    PER_VERTEX_INDEXED = _coin.SoTextureCoordinateBindingElement_PER_VERTEX_INDEXED
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoTextureCoordinateBindingElement_init(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, Binding binding)
        set(SoState state, Binding binding)
        """
        return _coin.SoTextureCoordinateBindingElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> Binding"""
        return _coin.SoTextureCoordinateBindingElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> Binding"""
        return _coin.SoTextureCoordinateBindingElement_getDefault()

    getDefault = staticmethod(getDefault)
SoTextureCoordinateBindingElement_swigregister = _coin.SoTextureCoordinateBindingElement_swigregister
SoTextureCoordinateBindingElement_swigregister(SoTextureCoordinateBindingElement)

def SoTextureCoordinateBindingElement_getClassTypeId():
  """SoTextureCoordinateBindingElement_getClassTypeId() -> SoType"""
  return _coin.SoTextureCoordinateBindingElement_getClassTypeId()

def SoTextureCoordinateBindingElement_getClassStackIndex():
  """SoTextureCoordinateBindingElement_getClassStackIndex() -> int"""
  return _coin.SoTextureCoordinateBindingElement_getClassStackIndex()

def SoTextureCoordinateBindingElement_createInstance():
  """SoTextureCoordinateBindingElement_createInstance() -> void"""
  return _coin.SoTextureCoordinateBindingElement_createInstance()

def SoTextureCoordinateBindingElement_initClass():
  """SoTextureCoordinateBindingElement_initClass()"""
  return _coin.SoTextureCoordinateBindingElement_initClass()

def SoTextureCoordinateBindingElement_set(*args):
  """
    set(SoState state, SoNode node, Binding binding)
    SoTextureCoordinateBindingElement_set(SoState state, Binding binding)
    """
  return _coin.SoTextureCoordinateBindingElement_set(*args)

def SoTextureCoordinateBindingElement_get(*args):
  """SoTextureCoordinateBindingElement_get(SoState state) -> Binding"""
  return _coin.SoTextureCoordinateBindingElement_get(*args)

def SoTextureCoordinateBindingElement_getDefault():
  """SoTextureCoordinateBindingElement_getDefault() -> Binding"""
  return _coin.SoTextureCoordinateBindingElement_getDefault()

class SoTextureCoordinateBinding(SoNode):
    """Proxy of C++ SoTextureCoordinateBinding class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateBinding_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTextureCoordinateBinding_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTextureCoordinateBinding_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTextureCoordinateBinding"""
        this = _coin.new_SoTextureCoordinateBinding()
        try: self.this.append(this)
        except: self.this = this
    PER_VERTEX = _coin.SoTextureCoordinateBinding_PER_VERTEX
    PER_VERTEX_INDEXED = _coin.SoTextureCoordinateBinding_PER_VERTEX_INDEXED
    DEFAULT = _coin.SoTextureCoordinateBinding_DEFAULT
    value = _swig_property(_coin.SoTextureCoordinateBinding_value_get, _coin.SoTextureCoordinateBinding_value_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoTextureCoordinateBinding_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateBinding_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateBinding_GLRender(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoTextureCoordinateBinding_pick(self, *args)

SoTextureCoordinateBinding_swigregister = _coin.SoTextureCoordinateBinding_swigregister
SoTextureCoordinateBinding_swigregister(SoTextureCoordinateBinding)

def SoTextureCoordinateBinding_getClassTypeId():
  """SoTextureCoordinateBinding_getClassTypeId() -> SoType"""
  return _coin.SoTextureCoordinateBinding_getClassTypeId()

def SoTextureCoordinateBinding_initClass():
  """SoTextureCoordinateBinding_initClass()"""
  return _coin.SoTextureCoordinateBinding_initClass()

class SoTransformation(SoNode):
    """Proxy of C++ SoTransformation class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTransformation_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTransformation_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTransformation_initClass()

    initClass = staticmethod(initClass)
SoTransformation_swigregister = _coin.SoTransformation_swigregister
SoTransformation_swigregister(SoTransformation)

def SoTransformation_getClassTypeId():
  """SoTransformation_getClassTypeId() -> SoType"""
  return _coin.SoTransformation_getClassTypeId()

def SoTransformation_initClass():
  """SoTransformation_initClass()"""
  return _coin.SoTransformation_initClass()

class SoUnits(SoTransformation):
    """Proxy of C++ SoUnits class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoUnits_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoUnits_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoUnits_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoUnits"""
        this = _coin.new_SoUnits()
        try: self.this.append(this)
        except: self.this = this
    METERS = _coin.SoUnits_METERS
    CENTIMETERS = _coin.SoUnits_CENTIMETERS
    MILLIMETERS = _coin.SoUnits_MILLIMETERS
    MICROMETERS = _coin.SoUnits_MICROMETERS
    MICRONS = _coin.SoUnits_MICRONS
    NANOMETERS = _coin.SoUnits_NANOMETERS
    ANGSTROMS = _coin.SoUnits_ANGSTROMS
    KILOMETERS = _coin.SoUnits_KILOMETERS
    FEET = _coin.SoUnits_FEET
    INCHES = _coin.SoUnits_INCHES
    POINTS = _coin.SoUnits_POINTS
    YARDS = _coin.SoUnits_YARDS
    MILES = _coin.SoUnits_MILES
    NAUTICAL_MILES = _coin.SoUnits_NAUTICAL_MILES
    units = _swig_property(_coin.SoUnits_units_get, _coin.SoUnits_units_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoUnits_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoUnits_callback(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoUnits_getBoundingBox(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoUnits_getMatrix(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoUnits_GLRender(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoUnits_pick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoUnits_getPrimitiveCount(self, *args)

SoUnits_swigregister = _coin.SoUnits_swigregister
SoUnits_swigregister(SoUnits)

def SoUnits_getClassTypeId():
  """SoUnits_getClassTypeId() -> SoType"""
  return _coin.SoUnits_getClassTypeId()

def SoUnits_initClass():
  """SoUnits_initClass()"""
  return _coin.SoUnits_initClass()

class SoCallbackAction(SoAction):
    """Proxy of C++ SoCallbackAction class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoCallbackAction_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoCallbackAction_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def addMethod(*args):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoCallbackAction_addMethod(*args)

    addMethod = staticmethod(addMethod)
    def enableElement(*args):
        """enableElement(SoType type, int stackindex)"""
        return _coin.SoCallbackAction_enableElement(*args)

    enableElement = staticmethod(enableElement)
    def initClass():
        """initClass()"""
        return _coin.SoCallbackAction_initClass()

    initClass = staticmethod(initClass)
    def __init__(self, *args): 
        """
        __init__(self) -> SoCallbackAction
        __init__(self, SbViewportRegion vp) -> SoCallbackAction
        """
        this = _coin.new_SoCallbackAction(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoCallbackAction
    __del__ = lambda self : None;
    def setViewportRegion(self, *args):
        """setViewportRegion(self, SbViewportRegion vp)"""
        return _coin.SoCallbackAction_setViewportRegion(self, *args)

    CONTINUE = _coin.SoCallbackAction_CONTINUE
    ABORT = _coin.SoCallbackAction_ABORT
    PRUNE = _coin.SoCallbackAction_PRUNE
    def getDecimationType(self):
        """getDecimationType(self) -> Type"""
        return _coin.SoCallbackAction_getDecimationType(self)

    def getDecimationPercentage(self):
        """getDecimationPercentage(self) -> float"""
        return _coin.SoCallbackAction_getDecimationPercentage(self)

    def getComplexity(self):
        """getComplexity(self) -> float"""
        return _coin.SoCallbackAction_getComplexity(self)

    def getComplexityType(self):
        """getComplexityType(self) -> Type"""
        return _coin.SoCallbackAction_getComplexityType(self)

    def getNumCoordinates(self):
        """getNumCoordinates(self) -> int32_t"""
        return _coin.SoCallbackAction_getNumCoordinates(self)

    def getCoordinate3(self, *args):
        """getCoordinate3(self, int index) -> SbVec3f"""
        return _coin.SoCallbackAction_getCoordinate3(self, *args)

    def getCoordinate4(self, *args):
        """getCoordinate4(self, int index) -> SbVec4f"""
        return _coin.SoCallbackAction_getCoordinate4(self, *args)

    def getDrawStyle(self):
        """getDrawStyle(self) -> Style"""
        return _coin.SoCallbackAction_getDrawStyle(self)

    def getLinePattern(self):
        """getLinePattern(self) -> unsigned short"""
        return _coin.SoCallbackAction_getLinePattern(self)

    def getLineWidth(self):
        """getLineWidth(self) -> float"""
        return _coin.SoCallbackAction_getLineWidth(self)

    def getPointSize(self):
        """getPointSize(self) -> float"""
        return _coin.SoCallbackAction_getPointSize(self)

    def getFontName(self):
        """getFontName(self) -> SbName"""
        return _coin.SoCallbackAction_getFontName(self)

    def getFontSize(self):
        """getFontSize(self) -> float"""
        return _coin.SoCallbackAction_getFontSize(self)

    def getLightModel(self):
        """getLightModel(self) -> Model"""
        return _coin.SoCallbackAction_getLightModel(self)

    def getLightAttenuation(self):
        """getLightAttenuation(self) -> SbVec3f"""
        return _coin.SoCallbackAction_getLightAttenuation(self)

    def getMaterialBinding(self):
        """getMaterialBinding(self) -> Binding"""
        return _coin.SoCallbackAction_getMaterialBinding(self)

    def getNumNormals(self):
        """getNumNormals(self) -> uint32_t"""
        return _coin.SoCallbackAction_getNumNormals(self)

    def getNormal(self, *args):
        """getNormal(self, int index) -> SbVec3f"""
        return _coin.SoCallbackAction_getNormal(self, *args)

    def getNormalBinding(self):
        """getNormalBinding(self) -> Binding"""
        return _coin.SoCallbackAction_getNormalBinding(self)

    def getNumProfileCoordinates(self):
        """getNumProfileCoordinates(self) -> int32_t"""
        return _coin.SoCallbackAction_getNumProfileCoordinates(self)

    def getProfileCoordinate2(self, *args):
        """getProfileCoordinate2(self, int index) -> SbVec2f"""
        return _coin.SoCallbackAction_getProfileCoordinate2(self, *args)

    def getProfileCoordinate3(self, *args):
        """getProfileCoordinate3(self, int index) -> SbVec3f"""
        return _coin.SoCallbackAction_getProfileCoordinate3(self, *args)

    def getProfile(self):
        """getProfile(self) -> SoNodeList"""
        return _coin.SoCallbackAction_getProfile(self)

    def getVertexOrdering(self):
        """getVertexOrdering(self) -> VertexOrdering"""
        return _coin.SoCallbackAction_getVertexOrdering(self)

    def getShapeType(self):
        """getShapeType(self) -> ShapeType"""
        return _coin.SoCallbackAction_getShapeType(self)

    def getFaceType(self):
        """getFaceType(self) -> FaceType"""
        return _coin.SoCallbackAction_getFaceType(self)

    def getCreaseAngle(self):
        """getCreaseAngle(self) -> float"""
        return _coin.SoCallbackAction_getCreaseAngle(self)

    def getNumTextureCoordinates(self):
        """getNumTextureCoordinates(self) -> int32_t"""
        return _coin.SoCallbackAction_getNumTextureCoordinates(self)

    def getTextureCoordinate2(self, *args):
        """getTextureCoordinate2(self, int index) -> SbVec2f"""
        return _coin.SoCallbackAction_getTextureCoordinate2(self, *args)

    def getTextureCoordinate3(self, *args):
        """getTextureCoordinate3(self, int index) -> SbVec3f"""
        return _coin.SoCallbackAction_getTextureCoordinate3(self, *args)

    def getTextureCoordinate4(self, *args):
        """getTextureCoordinate4(self, int index) -> SbVec4f"""
        return _coin.SoCallbackAction_getTextureCoordinate4(self, *args)

    def getTextureCoordinateBinding(self):
        """getTextureCoordinateBinding(self) -> Binding"""
        return _coin.SoCallbackAction_getTextureCoordinateBinding(self)

    def getTextureBlendColor(self):
        """getTextureBlendColor(self) -> SbColor"""
        return _coin.SoCallbackAction_getTextureBlendColor(self)

    def getTextureImage(self, *args):
        """
        getTextureImage(self, SbVec2s size, int numcomps) -> unsigned char
        getTextureImage(self, SbVec3s size, int numcomps) -> unsigned char
        """
        return _coin.SoCallbackAction_getTextureImage(self, *args)

    def getTextureMatrix(self):
        """getTextureMatrix(self) -> SbMatrix"""
        return _coin.SoCallbackAction_getTextureMatrix(self)

    def getTextureModel(self):
        """getTextureModel(self) -> Model"""
        return _coin.SoCallbackAction_getTextureModel(self)

    def getTextureWrapS(self):
        """getTextureWrapS(self) -> Wrap"""
        return _coin.SoCallbackAction_getTextureWrapS(self)

    def getTextureWrapT(self):
        """getTextureWrapT(self) -> Wrap"""
        return _coin.SoCallbackAction_getTextureWrapT(self)

    def getTextureWrapR(self):
        """getTextureWrapR(self) -> Wrap"""
        return _coin.SoCallbackAction_getTextureWrapR(self)

    def getModelMatrix(self):
        """getModelMatrix(self) -> SbMatrix"""
        return _coin.SoCallbackAction_getModelMatrix(self)

    def getUnits(self):
        """getUnits(self) -> Units"""
        return _coin.SoCallbackAction_getUnits(self)

    def getFocalDistance(self):
        """getFocalDistance(self) -> float"""
        return _coin.SoCallbackAction_getFocalDistance(self)

    def getProjectionMatrix(self):
        """getProjectionMatrix(self) -> SbMatrix"""
        return _coin.SoCallbackAction_getProjectionMatrix(self)

    def getViewingMatrix(self):
        """getViewingMatrix(self) -> SbMatrix"""
        return _coin.SoCallbackAction_getViewingMatrix(self)

    def getViewVolume(self):
        """getViewVolume(self) -> SbViewVolume"""
        return _coin.SoCallbackAction_getViewVolume(self)

    def getViewportRegion(self):
        """getViewportRegion(self) -> SbViewportRegion"""
        return _coin.SoCallbackAction_getViewportRegion(self)

    def getPickStyle(self):
        """getPickStyle(self) -> Style"""
        return _coin.SoCallbackAction_getPickStyle(self)

    def getSwitch(self):
        """getSwitch(self) -> int32_t"""
        return _coin.SoCallbackAction_getSwitch(self)

    def getCurrentResponse(self):
        """getCurrentResponse(self) -> Response"""
        return _coin.SoCallbackAction_getCurrentResponse(self)

    def invokePreCallbacks(self, *args):
        """invokePreCallbacks(self, SoNode node)"""
        return _coin.SoCallbackAction_invokePreCallbacks(self, *args)

    def invokePostCallbacks(self, *args):
        """invokePostCallbacks(self, SoNode node)"""
        return _coin.SoCallbackAction_invokePostCallbacks(self, *args)

    def invokeTriangleCallbacks(self, *args):
        """
        invokeTriangleCallbacks(self, SoShape shape, SoPrimitiveVertex v1, SoPrimitiveVertex v2, 
            SoPrimitiveVertex v3)
        """
        return _coin.SoCallbackAction_invokeTriangleCallbacks(self, *args)

    def invokeLineSegmentCallbacks(self, *args):
        """invokeLineSegmentCallbacks(self, SoShape shape, SoPrimitiveVertex v1, SoPrimitiveVertex v2)"""
        return _coin.SoCallbackAction_invokeLineSegmentCallbacks(self, *args)

    def invokePointCallbacks(self, *args):
        """invokePointCallbacks(self, SoShape shape, SoPrimitiveVertex v)"""
        return _coin.SoCallbackAction_invokePointCallbacks(self, *args)

    def shouldGeneratePrimitives(self, *args):
        """shouldGeneratePrimitives(self, SoShape shape) -> SbBool"""
        return _coin.SoCallbackAction_shouldGeneratePrimitives(self, *args)

    def getCurPathTail(self):
        """getCurPathTail(self) -> SoNode"""
        return _coin.SoCallbackAction_getCurPathTail(self)

    def setCurrentNode(self, *args):
        """setCurrentNode(self, SoNode node)"""
        return _coin.SoCallbackAction_setCurrentNode(self, *args)

    def setCallbackAll(self, *args):
        """setCallbackAll(self, SbBool callbackall)"""
        return _coin.SoCallbackAction_setCallbackAll(self, *args)

    def isCallbackAll(self):
        """isCallbackAll(self) -> SbBool"""
        return _coin.SoCallbackAction_isCallbackAll(self)

    def getMaterial(self, index = 0):
        """
        getMaterial(self, int index = 0) -> PyObject
        getMaterial(self) -> PyObject
        """
        return _coin.SoCallbackAction_getMaterial(self, index)

    def addPreCallback(self, *args):
        """
        addPreCallback(self, SoType type, SoCallbackActionCB cb, void userdata)
        addPreCallback(self, SoType type, PyObject pyfunc, PyObject userdata)
        """
        return _coin.SoCallbackAction_addPreCallback(self, *args)

    def addPostCallback(self, *args):
        """
        addPostCallback(self, SoType type, SoCallbackActionCB cb, void userdata)
        addPostCallback(self, SoType type, PyObject pyfunc, PyObject userdata)
        """
        return _coin.SoCallbackAction_addPostCallback(self, *args)

    def addPreTailCallback(self, *args):
        """
        addPreTailCallback(self, SoCallbackActionCB cb, void userdata)
        addPreTailCallback(self, PyObject pyfunc, PyObject userdata)
        """
        return _coin.SoCallbackAction_addPreTailCallback(self, *args)

    def addPostTailCallback(self, *args):
        """
        addPostTailCallback(self, SoCallbackActionCB cb, void userdata)
        addPostTailCallback(self, PyObject pyfunc, PyObject userdata)
        """
        return _coin.SoCallbackAction_addPostTailCallback(self, *args)

    def addTriangleCallback(self, *args):
        """
        addTriangleCallback(self, SoType type, SoTriangleCB cb, void userdata)
        addTriangleCallback(self, SoType type, PyObject pyfunc, PyObject userdata)
        """
        return _coin.SoCallbackAction_addTriangleCallback(self, *args)

    def addLineSegmentCallback(self, *args):
        """
        addLineSegmentCallback(self, SoType type, SoLineSegmentCB cb, void userdata)
        addLineSegmentCallback(self, SoType type, PyObject pyfunc, PyObject userdata)
        """
        return _coin.SoCallbackAction_addLineSegmentCallback(self, *args)

    def addPointCallback(self, *args):
        """
        addPointCallback(self, SoType type, SoPointCB cb, void userdata)
        addPointCallback(self, SoType type, PyObject pyfunc, PyObject userdata)
        """
        return _coin.SoCallbackAction_addPointCallback(self, *args)

SoCallbackAction_swigregister = _coin.SoCallbackAction_swigregister
SoCallbackAction_swigregister(SoCallbackAction)

def SoCallbackAction_getClassTypeId():
  """SoCallbackAction_getClassTypeId() -> SoType"""
  return _coin.SoCallbackAction_getClassTypeId()

def SoCallbackAction_addMethod(*args):
  """SoCallbackAction_addMethod(SoType type, SoActionMethod method)"""
  return _coin.SoCallbackAction_addMethod(*args)

def SoCallbackAction_enableElement(*args):
  """SoCallbackAction_enableElement(SoType type, int stackindex)"""
  return _coin.SoCallbackAction_enableElement(*args)

def SoCallbackAction_initClass():
  """SoCallbackAction_initClass()"""
  return _coin.SoCallbackAction_initClass()

class SbVec2f(object):
    """Proxy of C++ SbVec2f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbVec2f
        __init__(self, float v) -> SbVec2f
        __init__(self, float x, float y) -> SbVec2f
        __init__(self, SbVec2d v) -> SbVec2f
        __init__(self, SbVec2b v) -> SbVec2f
        __init__(self, SbVec2s v) -> SbVec2f
        __init__(self, SbVec2i32 v) -> SbVec2f
        """
        this = _coin.new_SbVec2f(*args)
        try: self.this.append(this)
        except: self.this = this
    def setValue(self, *args):
        """
        setValue(self, float v) -> SbVec2f
        setValue(self, float x, float y) -> SbVec2f
        setValue(self, SbVec2d v) -> SbVec2f
        setValue(self, SbVec2b v) -> SbVec2f
        setValue(self, SbVec2s v) -> SbVec2f
        setValue(self, SbVec2i32 v) -> SbVec2f
        """
        return _coin.SbVec2f_setValue(self, *args)

    def getValue(self):
        """getValue(self)"""
        return _coin.SbVec2f_getValue(self)

    def dot(self, *args):
        """dot(self, SbVec2f v) -> float"""
        return _coin.SbVec2f_dot(self, *args)

    def equals(self, *args):
        """equals(self, SbVec2f v, float tolerance) -> SbBool"""
        return _coin.SbVec2f_equals(self, *args)

    def length(self):
        """length(self) -> float"""
        return _coin.SbVec2f_length(self)

    def sqrLength(self):
        """sqrLength(self) -> float"""
        return _coin.SbVec2f_sqrLength(self)

    def negate(self):
        """negate(self)"""
        return _coin.SbVec2f_negate(self)

    def normalize(self):
        """normalize(self) -> float"""
        return _coin.SbVec2f_normalize(self)

    def __imul__(self, *args):
        """__imul__(self, float d) -> SbVec2f"""
        return _coin.SbVec2f___imul__(self, *args)

    def __idiv__(self, *args):
        """__idiv__(self, float d) -> SbVec2f"""
        return _coin.SbVec2f___idiv__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, SbVec2f v) -> SbVec2f"""
        return _coin.SbVec2f___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, SbVec2f v) -> SbVec2f"""
        return _coin.SbVec2f___isub__(self, *args)

    def __neg__(self):
        """__neg__(self) -> SbVec2f"""
        return _coin.SbVec2f___neg__(self)

    def output(self, *args):
        """output(self, FILE fp)"""
        return _coin.SbVec2f_output(self, *args)

    def __add__(self, *args):
        """__add__(self, SbVec2f u) -> SbVec2f"""
        return _coin.SbVec2f___add__(self, *args)

    def __sub__(self, *args):
        """__sub__(self, SbVec2f u) -> SbVec2f"""
        return _coin.SbVec2f___sub__(self, *args)

    def __mul__(self, *args):
        """__mul__(self, float d) -> SbVec2f"""
        return _coin.SbVec2f___mul__(self, *args)

    def __rmul__(self, *args):
        """__rmul__(self, float d) -> SbVec2f"""
        return _coin.SbVec2f___rmul__(self, *args)

    def __div__(self, *args):
        """__div__(self, float d) -> SbVec2f"""
        return _coin.SbVec2f___div__(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SbVec2f u) -> int"""
        return _coin.SbVec2f___eq__(self, *args)

    def __nq__(self, *args):
        """__nq__(self, SbVec2f u) -> int"""
        return _coin.SbVec2f___nq__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> float"""
        return _coin.SbVec2f___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, float value)"""
        return _coin.SbVec2f___setitem__(self, *args)

    def __iter__(self):
       for i in range(2):
          yield self[i]

    def __len__(self):
          return 2

    __swig_destroy__ = _coin.delete_SbVec2f
    __del__ = lambda self : None;
SbVec2f_swigregister = _coin.SbVec2f_swigregister
SbVec2f_swigregister(SbVec2f)

class SbViewportRegion(object):
    """Proxy of C++ SbViewportRegion class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbViewportRegion
        __init__(self, short width, short height) -> SbViewportRegion
        __init__(self, SbVec2s winSize) -> SbViewportRegion
        __init__(self, SbViewportRegion vpReg) -> SbViewportRegion
        """
        this = _coin.new_SbViewportRegion(*args)
        try: self.this.append(this)
        except: self.this = this
    def setWindowSize(self, *args):
        """
        setWindowSize(self, short width, short height)
        setWindowSize(self, SbVec2s winSize)
        """
        return _coin.SbViewportRegion_setWindowSize(self, *args)

    def setViewport(self, *args):
        """
        setViewport(self, float left, float bottom, float width, float height)
        setViewport(self, SbVec2f origin, SbVec2f size)
        """
        return _coin.SbViewportRegion_setViewport(self, *args)

    def setViewportPixels(self, *args):
        """
        setViewportPixels(self, short left, short bottom, short width, short height)
        setViewportPixels(self, SbVec2s origin, SbVec2s size)
        """
        return _coin.SbViewportRegion_setViewportPixels(self, *args)

    def getWindowSize(self):
        """getWindowSize(self) -> SbVec2s"""
        return _coin.SbViewportRegion_getWindowSize(self)

    def getViewportOrigin(self):
        """getViewportOrigin(self) -> SbVec2f"""
        return _coin.SbViewportRegion_getViewportOrigin(self)

    def getViewportOriginPixels(self):
        """getViewportOriginPixels(self) -> SbVec2s"""
        return _coin.SbViewportRegion_getViewportOriginPixels(self)

    def getViewportSize(self):
        """getViewportSize(self) -> SbVec2f"""
        return _coin.SbViewportRegion_getViewportSize(self)

    def getViewportSizePixels(self):
        """getViewportSizePixels(self) -> SbVec2s"""
        return _coin.SbViewportRegion_getViewportSizePixels(self)

    def getViewportAspectRatio(self):
        """getViewportAspectRatio(self) -> float"""
        return _coin.SbViewportRegion_getViewportAspectRatio(self)

    def scaleWidth(self, *args):
        """scaleWidth(self, float ratio)"""
        return _coin.SbViewportRegion_scaleWidth(self, *args)

    def scaleHeight(self, *args):
        """scaleHeight(self, float ratio)"""
        return _coin.SbViewportRegion_scaleHeight(self, *args)

    def setPixelsPerInch(self, *args):
        """setPixelsPerInch(self, float ppi)"""
        return _coin.SbViewportRegion_setPixelsPerInch(self, *args)

    def getPixelsPerInch(self):
        """getPixelsPerInch(self) -> float"""
        return _coin.SbViewportRegion_getPixelsPerInch(self)

    def getPixelsPerPoint(self):
        """getPixelsPerPoint(self) -> float"""
        return _coin.SbViewportRegion_getPixelsPerPoint(self)

    def output(self, *args):
        """output(self, FILE file)"""
        return _coin.SbViewportRegion_output(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SbViewportRegion u) -> int"""
        return _coin.SbViewportRegion___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SbViewportRegion u) -> int"""
        return _coin.SbViewportRegion___ne__(self, *args)

    __swig_destroy__ = _coin.delete_SbViewportRegion
    __del__ = lambda self : None;
SbViewportRegion_swigregister = _coin.SbViewportRegion_swigregister
SbViewportRegion_swigregister(SbViewportRegion)

class SoGLRenderAction(SoAction):
    """Proxy of C++ SoGLRenderAction class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoGLRenderAction_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLRenderAction_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def addMethod(*args):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoGLRenderAction_addMethod(*args)

    addMethod = staticmethod(addMethod)
    def enableElement(*args):
        """enableElement(SoType type, int stackindex)"""
        return _coin.SoGLRenderAction_enableElement(*args)

    enableElement = staticmethod(enableElement)
    def initClass():
        """initClass()"""
        return _coin.SoGLRenderAction_initClass()

    initClass = staticmethod(initClass)
    def __init__(self, *args): 
        """__init__(self, SbViewportRegion viewportregion) -> SoGLRenderAction"""
        this = _coin.new_SoGLRenderAction(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoGLRenderAction
    __del__ = lambda self : None;
    SCREEN_DOOR = _coin.SoGLRenderAction_SCREEN_DOOR
    ADD = _coin.SoGLRenderAction_ADD
    DELAYED_ADD = _coin.SoGLRenderAction_DELAYED_ADD
    SORTED_OBJECT_ADD = _coin.SoGLRenderAction_SORTED_OBJECT_ADD
    BLEND = _coin.SoGLRenderAction_BLEND
    DELAYED_BLEND = _coin.SoGLRenderAction_DELAYED_BLEND
    SORTED_OBJECT_BLEND = _coin.SoGLRenderAction_SORTED_OBJECT_BLEND
    SORTED_OBJECT_SORTED_TRIANGLE_ADD = _coin.SoGLRenderAction_SORTED_OBJECT_SORTED_TRIANGLE_ADD
    SORTED_OBJECT_SORTED_TRIANGLE_BLEND = _coin.SoGLRenderAction_SORTED_OBJECT_SORTED_TRIANGLE_BLEND
    NONE = _coin.SoGLRenderAction_NONE
    SORTED_LAYERS_BLEND = _coin.SoGLRenderAction_SORTED_LAYERS_BLEND
    ONE_PASS = _coin.SoGLRenderAction_ONE_PASS
    NONSOLID_SEPARATE_BACKFACE_PASS = _coin.SoGLRenderAction_NONSOLID_SEPARATE_BACKFACE_PASS
    CONTINUE = _coin.SoGLRenderAction_CONTINUE
    ABORT = _coin.SoGLRenderAction_ABORT
    PRUNE = _coin.SoGLRenderAction_PRUNE
    DELAY = _coin.SoGLRenderAction_DELAY
    BBOX_CENTER = _coin.SoGLRenderAction_BBOX_CENTER
    BBOX_CLOSEST_CORNER = _coin.SoGLRenderAction_BBOX_CLOSEST_CORNER
    BBOX_FARTHEST_CORNER = _coin.SoGLRenderAction_BBOX_FARTHEST_CORNER
    CUSTOM_CALLBACK = _coin.SoGLRenderAction_CUSTOM_CALLBACK
    def setViewportRegion(self, *args):
        """setViewportRegion(self, SbViewportRegion newregion)"""
        return _coin.SoGLRenderAction_setViewportRegion(self, *args)

    def getViewportRegion(self):
        """getViewportRegion(self) -> SbViewportRegion"""
        return _coin.SoGLRenderAction_getViewportRegion(self)

    def setUpdateArea(self, *args):
        """setUpdateArea(self, SbVec2f origin, SbVec2f size)"""
        return _coin.SoGLRenderAction_setUpdateArea(self, *args)

    def getUpdateArea(self, *args):
        """getUpdateArea(self, SbVec2f origin, SbVec2f size)"""
        return _coin.SoGLRenderAction_getUpdateArea(self, *args)

    def getAbortCallback(self, *args):
        """getAbortCallback(self, SoGLRenderAbortCB func_out, void userdata_out)"""
        return _coin.SoGLRenderAction_getAbortCallback(self, *args)

    def setTransparencyType(self, *args):
        """setTransparencyType(self, TransparencyType type)"""
        return _coin.SoGLRenderAction_setTransparencyType(self, *args)

    def getTransparencyType(self):
        """getTransparencyType(self) -> TransparencyType"""
        return _coin.SoGLRenderAction_getTransparencyType(self)

    def setTransparentDelayedObjectRenderType(self, *args):
        """setTransparentDelayedObjectRenderType(self, TransparentDelayedObjectRenderType type)"""
        return _coin.SoGLRenderAction_setTransparentDelayedObjectRenderType(self, *args)

    def getTransparentDelayedObjectRenderType(self):
        """getTransparentDelayedObjectRenderType(self) -> TransparentDelayedObjectRenderType"""
        return _coin.SoGLRenderAction_getTransparentDelayedObjectRenderType(self)

    def setSmoothing(self, *args):
        """setSmoothing(self, SbBool smooth)"""
        return _coin.SoGLRenderAction_setSmoothing(self, *args)

    def isSmoothing(self):
        """isSmoothing(self) -> SbBool"""
        return _coin.SoGLRenderAction_isSmoothing(self)

    def setNumPasses(self, *args):
        """setNumPasses(self, int num)"""
        return _coin.SoGLRenderAction_setNumPasses(self, *args)

    def getNumPasses(self):
        """getNumPasses(self) -> int"""
        return _coin.SoGLRenderAction_getNumPasses(self)

    def setPassUpdate(self, *args):
        """setPassUpdate(self, SbBool flag)"""
        return _coin.SoGLRenderAction_setPassUpdate(self, *args)

    def isPassUpdate(self):
        """isPassUpdate(self) -> SbBool"""
        return _coin.SoGLRenderAction_isPassUpdate(self)

    def setCacheContext(self, *args):
        """setCacheContext(self, uint32_t context)"""
        return _coin.SoGLRenderAction_setCacheContext(self, *args)

    def getCacheContext(self):
        """getCacheContext(self) -> uint32_t"""
        return _coin.SoGLRenderAction_getCacheContext(self)

    def addDelayedPath(self, *args):
        """addDelayedPath(self, SoPath path)"""
        return _coin.SoGLRenderAction_addDelayedPath(self, *args)

    def isRenderingDelayedPaths(self):
        """isRenderingDelayedPaths(self) -> SbBool"""
        return _coin.SoGLRenderAction_isRenderingDelayedPaths(self)

    def handleTransparency(self, istransparent = 0):
        """
        handleTransparency(self, SbBool istransparent = 0) -> SbBool
        handleTransparency(self) -> SbBool
        """
        return _coin.SoGLRenderAction_handleTransparency(self, istransparent)

    def setCurPass(self, *args):
        """setCurPass(self, int passnum, int numpasses)"""
        return _coin.SoGLRenderAction_setCurPass(self, *args)

    def getCurPass(self):
        """getCurPass(self) -> int"""
        return _coin.SoGLRenderAction_getCurPass(self)

    def abortNow(self):
        """abortNow(self) -> SbBool"""
        return _coin.SoGLRenderAction_abortNow(self)

    def setRenderingIsRemote(self, *args):
        """setRenderingIsRemote(self, SbBool isremote)"""
        return _coin.SoGLRenderAction_setRenderingIsRemote(self, *args)

    def getRenderingIsRemote(self):
        """getRenderingIsRemote(self) -> SbBool"""
        return _coin.SoGLRenderAction_getRenderingIsRemote(self)

    def invalidateState(self):
        """invalidateState(self)"""
        return _coin.SoGLRenderAction_invalidateState(self)

    def setSortedLayersNumPasses(self, *args):
        """setSortedLayersNumPasses(self, int num)"""
        return _coin.SoGLRenderAction_setSortedLayersNumPasses(self, *args)

    def getSortedLayersNumPasses(self):
        """getSortedLayersNumPasses(self) -> int"""
        return _coin.SoGLRenderAction_getSortedLayersNumPasses(self)

    def setSortedObjectOrderStrategy(self, *args):
        """
        setSortedObjectOrderStrategy(self, SortedObjectOrderStrategy strategy, SoGLSortedObjectOrderCB cb = None, 
            void closure = None)
        setSortedObjectOrderStrategy(self, SortedObjectOrderStrategy strategy, SoGLSortedObjectOrderCB cb = None)
        setSortedObjectOrderStrategy(self, SortedObjectOrderStrategy strategy)
        """
        return _coin.SoGLRenderAction_setSortedObjectOrderStrategy(self, *args)

    def setDelayedObjDepthWrite(self, *args):
        """setDelayedObjDepthWrite(self, SbBool write)"""
        return _coin.SoGLRenderAction_setDelayedObjDepthWrite(self, *args)

    def getDelayedObjDepthWrite(self):
        """getDelayedObjDepthWrite(self) -> SbBool"""
        return _coin.SoGLRenderAction_getDelayedObjDepthWrite(self)

    def isRenderingTranspPaths(self):
        """isRenderingTranspPaths(self) -> SbBool"""
        return _coin.SoGLRenderAction_isRenderingTranspPaths(self)

    def isRenderingTranspBackfaces(self):
        """isRenderingTranspBackfaces(self) -> SbBool"""
        return _coin.SoGLRenderAction_isRenderingTranspBackfaces(self)

    def setPassCallback(self, *args):
        """
        setPassCallback(self, SoGLRenderPassCB func, void userdata)
        setPassCallback(self, PyObject pyfunc, PyObject userdata)
        """
        return _coin.SoGLRenderAction_setPassCallback(self, *args)

    def setAbortCallback(self, *args):
        """
        setAbortCallback(self, SoGLRenderAbortCB func, void userdata)
        setAbortCallback(self, PyObject pyfunc, PyObject userdata)
        """
        return _coin.SoGLRenderAction_setAbortCallback(self, *args)

    def addPreRenderCallback(self, *args):
        """
        addPreRenderCallback(self, SoGLPreRenderCB func, void userdata)
        addPreRenderCallback(self, PyObject pyfunc, PyObject userdata)
        """
        return _coin.SoGLRenderAction_addPreRenderCallback(self, *args)

    def removePreRenderCallback(self, *args):
        """
        removePreRenderCallback(self, SoGLPreRenderCB func, void userdata)
        removePreRenderCallback(self, PyObject pyfunc, PyObject userdata)
        """
        return _coin.SoGLRenderAction_removePreRenderCallback(self, *args)

SoGLRenderAction_swigregister = _coin.SoGLRenderAction_swigregister
SoGLRenderAction_swigregister(SoGLRenderAction)

def SoGLRenderAction_getClassTypeId():
  """SoGLRenderAction_getClassTypeId() -> SoType"""
  return _coin.SoGLRenderAction_getClassTypeId()

def SoGLRenderAction_addMethod(*args):
  """SoGLRenderAction_addMethod(SoType type, SoActionMethod method)"""
  return _coin.SoGLRenderAction_addMethod(*args)

def SoGLRenderAction_enableElement(*args):
  """SoGLRenderAction_enableElement(SoType type, int stackindex)"""
  return _coin.SoGLRenderAction_enableElement(*args)

def SoGLRenderAction_initClass():
  """SoGLRenderAction_initClass()"""
  return _coin.SoGLRenderAction_initClass()

class SoBoxHighlightRenderAction(SoGLRenderAction):
    """Proxy of C++ SoBoxHighlightRenderAction class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoBoxHighlightRenderAction_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoBoxHighlightRenderAction_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def addMethod(*args):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoBoxHighlightRenderAction_addMethod(*args)

    addMethod = staticmethod(addMethod)
    def enableElement(*args):
        """enableElement(SoType type, int stackindex)"""
        return _coin.SoBoxHighlightRenderAction_enableElement(*args)

    enableElement = staticmethod(enableElement)
    def initClass():
        """initClass()"""
        return _coin.SoBoxHighlightRenderAction_initClass()

    initClass = staticmethod(initClass)
    def __init__(self, *args): 
        """
        __init__(self) -> SoBoxHighlightRenderAction
        __init__(self, SbViewportRegion viewportregion) -> SoBoxHighlightRenderAction
        """
        this = _coin.new_SoBoxHighlightRenderAction(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoBoxHighlightRenderAction
    __del__ = lambda self : None;
    def apply(self, *args):
        """
        apply(self, SoNode node)
        apply(self, SoPath path)
        apply(self, SoPathList pathlist, SbBool obeysrules = 0)
        apply(self, SoPathList pathlist)
        """
        return _coin.SoBoxHighlightRenderAction_apply(self, *args)

    def setVisible(self, *args):
        """setVisible(self, SbBool visible)"""
        return _coin.SoBoxHighlightRenderAction_setVisible(self, *args)

    def isVisible(self):
        """isVisible(self) -> SbBool"""
        return _coin.SoBoxHighlightRenderAction_isVisible(self)

    def setColor(self, *args):
        """setColor(self, SbColor color)"""
        return _coin.SoBoxHighlightRenderAction_setColor(self, *args)

    def getColor(self):
        """getColor(self) -> SbColor"""
        return _coin.SoBoxHighlightRenderAction_getColor(self)

    def setLinePattern(self, *args):
        """setLinePattern(self, unsigned short pattern)"""
        return _coin.SoBoxHighlightRenderAction_setLinePattern(self, *args)

    def getLinePattern(self):
        """getLinePattern(self) -> unsigned short"""
        return _coin.SoBoxHighlightRenderAction_getLinePattern(self)

    def setLineWidth(self, *args):
        """setLineWidth(self, float width)"""
        return _coin.SoBoxHighlightRenderAction_setLineWidth(self, *args)

    def getLineWidth(self):
        """getLineWidth(self) -> float"""
        return _coin.SoBoxHighlightRenderAction_getLineWidth(self)

SoBoxHighlightRenderAction_swigregister = _coin.SoBoxHighlightRenderAction_swigregister
SoBoxHighlightRenderAction_swigregister(SoBoxHighlightRenderAction)

def SoBoxHighlightRenderAction_getClassTypeId():
  """SoBoxHighlightRenderAction_getClassTypeId() -> SoType"""
  return _coin.SoBoxHighlightRenderAction_getClassTypeId()

def SoBoxHighlightRenderAction_addMethod(*args):
  """SoBoxHighlightRenderAction_addMethod(SoType type, SoActionMethod method)"""
  return _coin.SoBoxHighlightRenderAction_addMethod(*args)

def SoBoxHighlightRenderAction_enableElement(*args):
  """SoBoxHighlightRenderAction_enableElement(SoType type, int stackindex)"""
  return _coin.SoBoxHighlightRenderAction_enableElement(*args)

def SoBoxHighlightRenderAction_initClass():
  """SoBoxHighlightRenderAction_initClass()"""
  return _coin.SoBoxHighlightRenderAction_initClass()

class SoLineHighlightRenderAction(SoGLRenderAction):
    """Proxy of C++ SoLineHighlightRenderAction class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoLineHighlightRenderAction_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoLineHighlightRenderAction_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def addMethod(*args):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoLineHighlightRenderAction_addMethod(*args)

    addMethod = staticmethod(addMethod)
    def enableElement(*args):
        """enableElement(SoType type, int stackindex)"""
        return _coin.SoLineHighlightRenderAction_enableElement(*args)

    enableElement = staticmethod(enableElement)
    def initClass():
        """initClass()"""
        return _coin.SoLineHighlightRenderAction_initClass()

    initClass = staticmethod(initClass)
    def __init__(self, *args): 
        """
        __init__(self) -> SoLineHighlightRenderAction
        __init__(self, SbViewportRegion viewportregion) -> SoLineHighlightRenderAction
        """
        this = _coin.new_SoLineHighlightRenderAction(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoLineHighlightRenderAction
    __del__ = lambda self : None;
    def apply(self, *args):
        """
        apply(self, SoNode node)
        apply(self, SoPath path)
        apply(self, SoPathList pathlist, SbBool obeysrules = 0)
        apply(self, SoPathList pathlist)
        """
        return _coin.SoLineHighlightRenderAction_apply(self, *args)

    def setVisible(self, *args):
        """setVisible(self, SbBool visible)"""
        return _coin.SoLineHighlightRenderAction_setVisible(self, *args)

    def isVisible(self):
        """isVisible(self) -> SbBool"""
        return _coin.SoLineHighlightRenderAction_isVisible(self)

    def setColor(self, *args):
        """setColor(self, SbColor color)"""
        return _coin.SoLineHighlightRenderAction_setColor(self, *args)

    def getColor(self):
        """getColor(self) -> SbColor"""
        return _coin.SoLineHighlightRenderAction_getColor(self)

    def setLinePattern(self, *args):
        """setLinePattern(self, uint16_t pattern)"""
        return _coin.SoLineHighlightRenderAction_setLinePattern(self, *args)

    def getLinePattern(self):
        """getLinePattern(self) -> uint16_t"""
        return _coin.SoLineHighlightRenderAction_getLinePattern(self)

    def setLineWidth(self, *args):
        """setLineWidth(self, float width)"""
        return _coin.SoLineHighlightRenderAction_setLineWidth(self, *args)

    def getLineWidth(self):
        """getLineWidth(self) -> float"""
        return _coin.SoLineHighlightRenderAction_getLineWidth(self)

SoLineHighlightRenderAction_swigregister = _coin.SoLineHighlightRenderAction_swigregister
SoLineHighlightRenderAction_swigregister(SoLineHighlightRenderAction)

def SoLineHighlightRenderAction_getClassTypeId():
  """SoLineHighlightRenderAction_getClassTypeId() -> SoType"""
  return _coin.SoLineHighlightRenderAction_getClassTypeId()

def SoLineHighlightRenderAction_addMethod(*args):
  """SoLineHighlightRenderAction_addMethod(SoType type, SoActionMethod method)"""
  return _coin.SoLineHighlightRenderAction_addMethod(*args)

def SoLineHighlightRenderAction_enableElement(*args):
  """SoLineHighlightRenderAction_enableElement(SoType type, int stackindex)"""
  return _coin.SoLineHighlightRenderAction_enableElement(*args)

def SoLineHighlightRenderAction_initClass():
  """SoLineHighlightRenderAction_initClass()"""
  return _coin.SoLineHighlightRenderAction_initClass()

class SbBox3f(object):
    """Proxy of C++ SbBox3f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbBox3f
        __init__(self, float xmin, float ymin, float zmin, float xmax, float ymax, 
            float zmax) -> SbBox3f
        __init__(self, SbVec3f minpoint, SbVec3f maxpoint) -> SbBox3f
        __init__(self, SbBox3d box) -> SbBox3f
        __init__(self, SbBox3s box) -> SbBox3f
        __init__(self, SbBox3i32 box) -> SbBox3f
        """
        this = _coin.new_SbBox3f(*args)
        try: self.this.append(this)
        except: self.this = this
    def setBounds(self, *args):
        """
        setBounds(self, float xmin, float ymin, float zmin, float xmax, float ymax, 
            float zmax) -> SbBox3f
        setBounds(self, SbVec3f minpoint, SbVec3f maxpoint) -> SbBox3f
        setBounds(self, SbBox3d box) -> SbBox3f
        setBounds(self, SbBox3s box) -> SbBox3f
        setBounds(self, SbBox3i32 box) -> SbBox3f
        """
        return _coin.SbBox3f_setBounds(self, *args)

    def getBounds(self, *args):
        """
        getBounds(self, float xmin, float ymin, float zmin, float xmax, float ymax, 
            float zmax)
        getBounds(self, SbVec3f minpoint, SbVec3f maxpoint)
        """
        return _coin.SbBox3f_getBounds(self, *args)

    def getMin(self, *args):
        """
        getMin(self) -> SbVec3f
        getMin(self) -> SbVec3f
        """
        return _coin.SbBox3f_getMin(self, *args)

    def getMax(self, *args):
        """
        getMax(self) -> SbVec3f
        getMax(self) -> SbVec3f
        """
        return _coin.SbBox3f_getMax(self, *args)

    def extendBy(self, *args):
        """
        extendBy(self, SbVec3f pt)
        extendBy(self, SbBox3f box)
        """
        return _coin.SbBox3f_extendBy(self, *args)

    def transform(self, *args):
        """transform(self, SbMatrix matrix)"""
        return _coin.SbBox3f_transform(self, *args)

    def makeEmpty(self):
        """makeEmpty(self)"""
        return _coin.SbBox3f_makeEmpty(self)

    def isEmpty(self):
        """isEmpty(self) -> SbBool"""
        return _coin.SbBox3f_isEmpty(self)

    def hasVolume(self):
        """hasVolume(self) -> SbBool"""
        return _coin.SbBox3f_hasVolume(self)

    def getVolume(self):
        """getVolume(self) -> float"""
        return _coin.SbBox3f_getVolume(self)

    def intersect(self, *args):
        """
        intersect(self, SbVec3f pt) -> SbBool
        intersect(self, SbBox3f box) -> SbBool
        """
        return _coin.SbBox3f_intersect(self, *args)

    def getClosestPoint(self, *args):
        """getClosestPoint(self, SbVec3f point) -> SbVec3f"""
        return _coin.SbBox3f_getClosestPoint(self, *args)

    def outside(self, *args):
        """outside(self, SbMatrix mvp, int cullbits) -> SbBool"""
        return _coin.SbBox3f_outside(self, *args)

    def getCenter(self):
        """getCenter(self) -> SbVec3f"""
        return _coin.SbBox3f_getCenter(self)

    def getOrigin(self, *args):
        """getOrigin(self, float originX, float originY, float originZ)"""
        return _coin.SbBox3f_getOrigin(self, *args)

    def getSize(self, *args):
        """
        getSize(self, float sizeX, float sizeY, float sizeZ)
        getSize(self) -> SbVec3f
        """
        return _coin.SbBox3f_getSize(self, *args)

    def getSpan(self, *args):
        """getSpan(self, SbVec3f dir, float dmin, float dmax)"""
        return _coin.SbBox3f_getSpan(self, *args)

    def output(self, *args):
        """output(self, FILE file)"""
        return _coin.SbBox3f_output(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SbBox3f u) -> int"""
        return _coin.SbBox3f___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SbBox3f u) -> int"""
        return _coin.SbBox3f___ne__(self, *args)

    __swig_destroy__ = _coin.delete_SbBox3f
    __del__ = lambda self : None;
SbBox3f_swigregister = _coin.SbBox3f_swigregister
SbBox3f_swigregister(SbBox3f)

class SbMatrix(object):
    """Proxy of C++ SbMatrix class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbMatrix
        __init__(self, float a11, float a12, float a13, float a14, float a21, 
            float a22, float a23, float a24, float a31, 
            float a32, float a33, float a34, float a41, 
            float a42, float a43, float a44) -> SbMatrix
        __init__(self, SbMat matrix) -> SbMatrix
        __init__(self, SbMat matrix) -> SbMatrix
        """
        this = _coin.new_SbMatrix(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SbMatrix
    __del__ = lambda self : None;
    def setValue(self, *args):
        """
        setValue(self, SbMat m)
        setValue(self, SbDPMatrix m)
        """
        return _coin.SbMatrix_setValue(self, *args)

    def makeIdentity(self):
        """makeIdentity(self)"""
        return _coin.SbMatrix_makeIdentity(self)

    def setRotate(self, *args):
        """setRotate(self, SbRotation q)"""
        return _coin.SbMatrix_setRotate(self, *args)

    def inverse(self):
        """inverse(self) -> SbMatrix"""
        return _coin.SbMatrix_inverse(self)

    def det3(self, *args):
        """
        det3(self, int r1, int r2, int r3, int c1, int c2, int c3) -> float
        det3(self) -> float
        """
        return _coin.SbMatrix_det3(self, *args)

    def det4(self):
        """det4(self) -> float"""
        return _coin.SbMatrix_det4(self)

    def equals(self, *args):
        """equals(self, SbMatrix m, float tolerance) -> SbBool"""
        return _coin.SbMatrix_equals(self, *args)

    def __imul__(self, *args):
        """__imul__(self, SbMatrix m) -> SbMatrix"""
        return _coin.SbMatrix___imul__(self, *args)

    def getValue(self, *args):
        """
        getValue(self) -> SbMat
        getValue(self, SbMat m)
        """
        return _coin.SbMatrix_getValue(self, *args)

    def identity():
        """identity() -> SbMatrix"""
        return _coin.SbMatrix_identity()

    identity = staticmethod(identity)
    def setScale(self, *args):
        """
        setScale(self, float s)
        setScale(self, SbVec3f s)
        """
        return _coin.SbMatrix_setScale(self, *args)

    def setTranslate(self, *args):
        """setTranslate(self, SbVec3f t)"""
        return _coin.SbMatrix_setTranslate(self, *args)

    def setTransform(self, *args):
        """
        setTransform(self, SbVec3f t, SbRotation r, SbVec3f s)
        setTransform(self, SbVec3f t, SbRotation r, SbVec3f s, SbRotation so)
        setTransform(self, SbVec3f translation, SbRotation rotation, SbVec3f scaleFactor, 
            SbRotation scaleOrientation, SbVec3f center)
        """
        return _coin.SbMatrix_setTransform(self, *args)

    def factor(self, *args):
        """factor(self, SbMatrix r, SbVec3f s, SbMatrix u, SbVec3f t, SbMatrix proj) -> SbBool"""
        return _coin.SbMatrix_factor(self, *args)

    def LUDecomposition(self, *args):
        """LUDecomposition(self, int index, float d) -> SbBool"""
        return _coin.SbMatrix_LUDecomposition(self, *args)

    def LUBackSubstitution(self, *args):
        """LUBackSubstitution(self, int index, float b)"""
        return _coin.SbMatrix_LUBackSubstitution(self, *args)

    def transpose(self):
        """transpose(self) -> SbMatrix"""
        return _coin.SbMatrix_transpose(self)

    def multRight(self, *args):
        """multRight(self, SbMatrix m) -> SbMatrix"""
        return _coin.SbMatrix_multRight(self, *args)

    def multLeft(self, *args):
        """multLeft(self, SbMatrix m) -> SbMatrix"""
        return _coin.SbMatrix_multLeft(self, *args)

    def multMatrixVec(self, *args):
        """multMatrixVec(self, SbVec3f src)"""
        return _coin.SbMatrix_multMatrixVec(self, *args)

    def multDirMatrix(self, *args):
        """multDirMatrix(self, SbVec3f src)"""
        return _coin.SbMatrix_multDirMatrix(self, *args)

    def multLineMatrix(self, *args):
        """multLineMatrix(self, SbLine src, SbLine dst)"""
        return _coin.SbMatrix_multLineMatrix(self, *args)

    def multVecMatrix(self, *args):
        """
        multVecMatrix(self, SbVec3f src)
        multVecMatrix(self, SbVec4f src)
        """
        return _coin.SbMatrix_multVecMatrix(self, *args)

    def output(self, *args):
        """output(self, FILE fp)"""
        return _coin.SbMatrix_output(self, *args)

    def getTransform(self, *args):
        """
        getTransform(self, SbVec3f t, SbRotation r, SbVec3f s, SbRotation so)
        getTransform(self) -> PyObject
        getTransform(self, SbVec3f center) -> PyObject
        """
        return _coin.SbMatrix_getTransform(self, *args)

    def __mul__(self, *args):
        """
        __mul__(self, SbMatrix u) -> SbMatrix
        __mul__(self, SbVec3f u) -> SbVec3f
        """
        return _coin.SbMatrix___mul__(self, *args)

    def __rmul__(self, *args):
        """__rmul__(self, SbVec3f u) -> SbVec3f"""
        return _coin.SbMatrix___rmul__(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SbMatrix u) -> int"""
        return _coin.SbMatrix___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SbMatrix u) -> int"""
        return _coin.SbMatrix___ne__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> float"""
        return _coin.SbMatrix___getitem__(self, *args)

SbMatrix_swigregister = _coin.SbMatrix_swigregister
SbMatrix_swigregister(SbMatrix)

def SbMatrix_identity():
  """SbMatrix_identity() -> SbMatrix"""
  return _coin.SbMatrix_identity()

class SbXfBox3f(SbBox3f):
    """Proxy of C++ SbXfBox3f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbXfBox3f
        __init__(self, SbVec3f boxmin, SbVec3f boxmax) -> SbXfBox3f
        __init__(self, SbBox3f box) -> SbXfBox3f
        """
        this = _coin.new_SbXfBox3f(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SbXfBox3f
    __del__ = lambda self : None;
    def setTransform(self, *args):
        """setTransform(self, SbMatrix m)"""
        return _coin.SbXfBox3f_setTransform(self, *args)

    def getTransform(self):
        """getTransform(self) -> SbMatrix"""
        return _coin.SbXfBox3f_getTransform(self)

    def getInverse(self):
        """getInverse(self) -> SbMatrix"""
        return _coin.SbXfBox3f_getInverse(self)

    def getCenter(self):
        """getCenter(self) -> SbVec3f"""
        return _coin.SbXfBox3f_getCenter(self)

    def extendBy(self, *args):
        """
        extendBy(self, SbVec3f pt)
        extendBy(self, SbBox3f bb)
        extendBy(self, SbXfBox3f bb)
        """
        return _coin.SbXfBox3f_extendBy(self, *args)

    def intersect(self, *args):
        """
        intersect(self, SbVec3f pt) -> SbBool
        intersect(self, SbBox3f bb) -> SbBool
        intersect(self, SbXfBox3f bb) -> SbBool
        """
        return _coin.SbXfBox3f_intersect(self, *args)

    def getSpan(self, *args):
        """getSpan(self, SbVec3f direction, float dMin, float dMax)"""
        return _coin.SbXfBox3f_getSpan(self, *args)

    def project(self):
        """project(self) -> SbBox3f"""
        return _coin.SbXfBox3f_project(self)

    def transform(self, *args):
        """transform(self, SbMatrix m)"""
        return _coin.SbXfBox3f_transform(self, *args)

    def getVolume(self):
        """getVolume(self) -> float"""
        return _coin.SbXfBox3f_getVolume(self)

    def output(self, *args):
        """output(self, FILE file)"""
        return _coin.SbXfBox3f_output(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SbXfBox3f u) -> int"""
        return _coin.SbXfBox3f___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SbXfBox3f u) -> int"""
        return _coin.SbXfBox3f___ne__(self, *args)

SbXfBox3f_swigregister = _coin.SbXfBox3f_swigregister
SbXfBox3f_swigregister(SbXfBox3f)

class SoGetBoundingBoxAction(SoAction):
    """Proxy of C++ SoGetBoundingBoxAction class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoGetBoundingBoxAction_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGetBoundingBoxAction_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def addMethod(*args):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoGetBoundingBoxAction_addMethod(*args)

    addMethod = staticmethod(addMethod)
    def enableElement(*args):
        """enableElement(SoType type, int stackindex)"""
        return _coin.SoGetBoundingBoxAction_enableElement(*args)

    enableElement = staticmethod(enableElement)
    def initClass():
        """initClass()"""
        return _coin.SoGetBoundingBoxAction_initClass()

    initClass = staticmethod(initClass)
    def __init__(self, *args): 
        """__init__(self, SbViewportRegion vp) -> SoGetBoundingBoxAction"""
        this = _coin.new_SoGetBoundingBoxAction(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoGetBoundingBoxAction
    __del__ = lambda self : None;
    TRANSFORM = _coin.SoGetBoundingBoxAction_TRANSFORM
    BBOX = _coin.SoGetBoundingBoxAction_BBOX
    ALL = _coin.SoGetBoundingBoxAction_ALL
    def setViewportRegion(self, *args):
        """setViewportRegion(self, SbViewportRegion newregion)"""
        return _coin.SoGetBoundingBoxAction_setViewportRegion(self, *args)

    def getViewportRegion(self):
        """getViewportRegion(self) -> SbViewportRegion"""
        return _coin.SoGetBoundingBoxAction_getViewportRegion(self)

    def getBoundingBox(self):
        """getBoundingBox(self) -> SbBox3f"""
        return _coin.SoGetBoundingBoxAction_getBoundingBox(self)

    def getXfBoundingBox(self):
        """getXfBoundingBox(self) -> SbXfBox3f"""
        return _coin.SoGetBoundingBoxAction_getXfBoundingBox(self)

    def getCenter(self):
        """getCenter(self) -> SbVec3f"""
        return _coin.SoGetBoundingBoxAction_getCenter(self)

    def setInCameraSpace(self, *args):
        """setInCameraSpace(self, SbBool flag)"""
        return _coin.SoGetBoundingBoxAction_setInCameraSpace(self, *args)

    def isInCameraSpace(self):
        """isInCameraSpace(self) -> SbBool"""
        return _coin.SoGetBoundingBoxAction_isInCameraSpace(self)

    def setResetPath(self, *args):
        """
        setResetPath(self, SoPath path, SbBool resetbefore = 1, ResetType what = ALL)
        setResetPath(self, SoPath path, SbBool resetbefore = 1)
        setResetPath(self, SoPath path)
        """
        return _coin.SoGetBoundingBoxAction_setResetPath(self, *args)

    def getResetPath(self):
        """getResetPath(self) -> SoPath"""
        return _coin.SoGetBoundingBoxAction_getResetPath(self)

    def isResetPath(self):
        """isResetPath(self) -> SbBool"""
        return _coin.SoGetBoundingBoxAction_isResetPath(self)

    def isResetBefore(self):
        """isResetBefore(self) -> SbBool"""
        return _coin.SoGetBoundingBoxAction_isResetBefore(self)

    def getWhatReset(self):
        """getWhatReset(self) -> ResetType"""
        return _coin.SoGetBoundingBoxAction_getWhatReset(self)

    def checkResetBefore(self):
        """checkResetBefore(self)"""
        return _coin.SoGetBoundingBoxAction_checkResetBefore(self)

    def checkResetAfter(self):
        """checkResetAfter(self)"""
        return _coin.SoGetBoundingBoxAction_checkResetAfter(self)

    def extendBy(self, *args):
        """
        extendBy(self, SbBox3f box)
        extendBy(self, SbXfBox3f box)
        """
        return _coin.SoGetBoundingBoxAction_extendBy(self, *args)

    def setCenter(self, *args):
        """setCenter(self, SbVec3f center, SbBool transformcenter)"""
        return _coin.SoGetBoundingBoxAction_setCenter(self, *args)

    def isCenterSet(self):
        """isCenterSet(self) -> SbBool"""
        return _coin.SoGetBoundingBoxAction_isCenterSet(self)

    def resetCenter(self):
        """resetCenter(self)"""
        return _coin.SoGetBoundingBoxAction_resetCenter(self)

SoGetBoundingBoxAction_swigregister = _coin.SoGetBoundingBoxAction_swigregister
SoGetBoundingBoxAction_swigregister(SoGetBoundingBoxAction)

def SoGetBoundingBoxAction_getClassTypeId():
  """SoGetBoundingBoxAction_getClassTypeId() -> SoType"""
  return _coin.SoGetBoundingBoxAction_getClassTypeId()

def SoGetBoundingBoxAction_addMethod(*args):
  """SoGetBoundingBoxAction_addMethod(SoType type, SoActionMethod method)"""
  return _coin.SoGetBoundingBoxAction_addMethod(*args)

def SoGetBoundingBoxAction_enableElement(*args):
  """SoGetBoundingBoxAction_enableElement(SoType type, int stackindex)"""
  return _coin.SoGetBoundingBoxAction_enableElement(*args)

def SoGetBoundingBoxAction_initClass():
  """SoGetBoundingBoxAction_initClass()"""
  return _coin.SoGetBoundingBoxAction_initClass()

class SbVec4f(object):
    """Proxy of C++ SbVec4f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbVec4f
        __init__(self, float v) -> SbVec4f
        __init__(self, float x, float y, float z, float w) -> SbVec4f
        __init__(self, SbVec4d v) -> SbVec4f
        __init__(self, SbVec4b v) -> SbVec4f
        __init__(self, SbVec4s v) -> SbVec4f
        __init__(self, SbVec4i32 v) -> SbVec4f
        """
        this = _coin.new_SbVec4f(*args)
        try: self.this.append(this)
        except: self.this = this
    def setValue(self, *args):
        """
        setValue(self, float v) -> SbVec4f
        setValue(self, float x, float y, float z, float w) -> SbVec4f
        setValue(self, SbVec4d v) -> SbVec4f
        setValue(self, SbVec4b v) -> SbVec4f
        setValue(self, SbVec4s v) -> SbVec4f
        setValue(self, SbVec4i32 v) -> SbVec4f
        """
        return _coin.SbVec4f_setValue(self, *args)

    def getValue(self):
        """getValue(self) -> float"""
        return _coin.SbVec4f_getValue(self)

    def equals(self, *args):
        """equals(self, SbVec4f v, float tolerance) -> SbBool"""
        return _coin.SbVec4f_equals(self, *args)

    def dot(self, *args):
        """dot(self, SbVec4f v) -> float"""
        return _coin.SbVec4f_dot(self, *args)

    def getReal(self, *args):
        """getReal(self, SbVec3f v)"""
        return _coin.SbVec4f_getReal(self, *args)

    def length(self):
        """length(self) -> float"""
        return _coin.SbVec4f_length(self)

    def sqrLength(self):
        """sqrLength(self) -> float"""
        return _coin.SbVec4f_sqrLength(self)

    def negate(self):
        """negate(self)"""
        return _coin.SbVec4f_negate(self)

    def normalize(self):
        """normalize(self) -> float"""
        return _coin.SbVec4f_normalize(self)

    def __imul__(self, *args):
        """__imul__(self, float d) -> SbVec4f"""
        return _coin.SbVec4f___imul__(self, *args)

    def __idiv__(self, *args):
        """__idiv__(self, float d) -> SbVec4f"""
        return _coin.SbVec4f___idiv__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, SbVec4f v) -> SbVec4f"""
        return _coin.SbVec4f___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, SbVec4f v) -> SbVec4f"""
        return _coin.SbVec4f___isub__(self, *args)

    def __neg__(self):
        """__neg__(self) -> SbVec4f"""
        return _coin.SbVec4f___neg__(self)

    def output(self, *args):
        """output(self, FILE fp)"""
        return _coin.SbVec4f_output(self, *args)

    def __add__(self, *args):
        """__add__(self, SbVec4f u) -> SbVec4f"""
        return _coin.SbVec4f___add__(self, *args)

    def __sub__(self, *args):
        """__sub__(self, SbVec4f u) -> SbVec4f"""
        return _coin.SbVec4f___sub__(self, *args)

    def __mul__(self, *args):
        """
        __mul__(self, float d) -> SbVec4f
        __mul__(self, SbMatrix m) -> SbVec4f
        """
        return _coin.SbVec4f___mul__(self, *args)

    def __rmul__(self, *args):
        """__rmul__(self, float d) -> SbVec4f"""
        return _coin.SbVec4f___rmul__(self, *args)

    def __div__(self, *args):
        """__div__(self, float d) -> SbVec4f"""
        return _coin.SbVec4f___div__(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SbVec4f u) -> int"""
        return _coin.SbVec4f___eq__(self, *args)

    def __nq__(self, *args):
        """__nq__(self, SbVec4f u) -> int"""
        return _coin.SbVec4f___nq__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> float"""
        return _coin.SbVec4f___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, float value)"""
        return _coin.SbVec4f___setitem__(self, *args)

    def __iter__(self):
       for i in range(4):
          yield self[i]
       
    def __len__(self):
          return 4

    __swig_destroy__ = _coin.delete_SbVec4f
    __del__ = lambda self : None;
SbVec4f_swigregister = _coin.SbVec4f_swigregister
SbVec4f_swigregister(SbVec4f)

class SbRotation(object):
    """Proxy of C++ SbRotation class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbRotation
        __init__(self, SbVec3f axis, float radians) -> SbRotation
        __init__(self, float q) -> SbRotation
        __init__(self, float q0, float q1, float q2, float q3) -> SbRotation
        __init__(self, SbMatrix m) -> SbRotation
        __init__(self, SbVec3f rotateFrom, SbVec3f rotateTo) -> SbRotation
        """
        this = _coin.new_SbRotation(*args)
        try: self.this.append(this)
        except: self.this = this
    def getValue(self):
        """getValue(self) -> float"""
        return _coin.SbRotation_getValue(self)

    def getAxisAngle(self):
        """getAxisAngle(self)"""
        return _coin.SbRotation_getAxisAngle(self)

    def getMatrix(self):
        """getMatrix(self)"""
        return _coin.SbRotation_getMatrix(self)

    def invert(self):
        """invert(self) -> SbRotation"""
        return _coin.SbRotation_invert(self)

    def inverse(self):
        """inverse(self) -> SbRotation"""
        return _coin.SbRotation_inverse(self)

    def setValue(self, *args):
        """
        setValue(self, float q0, float q1, float q2, float q3) -> SbRotation
        setValue(self, float q) -> SbRotation
        setValue(self, SbMatrix m) -> SbRotation
        setValue(self, SbVec3f axis, float radians) -> SbRotation
        setValue(self, SbVec3f rotateFrom, SbVec3f rotateTo) -> SbRotation
        """
        return _coin.SbRotation_setValue(self, *args)

    def __imul__(self, *args):
        """
        __imul__(self, SbRotation q) -> SbRotation
        __imul__(self, float s) -> SbRotation
        """
        return _coin.SbRotation___imul__(self, *args)

    def equals(self, *args):
        """equals(self, SbRotation r, float tolerance) -> SbBool"""
        return _coin.SbRotation_equals(self, *args)

    def multVec(self, *args):
        """multVec(self, SbVec3f src)"""
        return _coin.SbRotation_multVec(self, *args)

    def scaleAngle(self, *args):
        """scaleAngle(self, float scaleFactor)"""
        return _coin.SbRotation_scaleAngle(self, *args)

    def slerp(*args):
        """slerp(SbRotation rot0, SbRotation rot1, float t) -> SbRotation"""
        return _coin.SbRotation_slerp(*args)

    slerp = staticmethod(slerp)
    def identity():
        """identity() -> SbRotation"""
        return _coin.SbRotation_identity()

    identity = staticmethod(identity)
    def output(self, *args):
        """output(self, FILE fp)"""
        return _coin.SbRotation_output(self, *args)

    def __mul__(self, *args):
        """
        __mul__(self, SbRotation u) -> SbRotation
        __mul__(self, double d) -> SbRotation
        __mul__(self, SbVec3f v) -> SbVec3f
        """
        return _coin.SbRotation___mul__(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SbRotation u) -> int"""
        return _coin.SbRotation___eq__(self, *args)

    def __nq__(self, *args):
        """__nq__(self, SbRotation u) -> int"""
        return _coin.SbRotation___nq__(self, *args)

    __swig_destroy__ = _coin.delete_SbRotation
    __del__ = lambda self : None;
SbRotation_swigregister = _coin.SbRotation_swigregister
SbRotation_swigregister(SbRotation)

def SbRotation_slerp(*args):
  """SbRotation_slerp(SbRotation rot0, SbRotation rot1, float t) -> SbRotation"""
  return _coin.SbRotation_slerp(*args)

def SbRotation_identity():
  """SbRotation_identity() -> SbRotation"""
  return _coin.SbRotation_identity()

class SoGetMatrixAction(SoAction):
    """Proxy of C++ SoGetMatrixAction class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoGetMatrixAction_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGetMatrixAction_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def addMethod(*args):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoGetMatrixAction_addMethod(*args)

    addMethod = staticmethod(addMethod)
    def enableElement(*args):
        """enableElement(SoType type, int stackindex)"""
        return _coin.SoGetMatrixAction_enableElement(*args)

    enableElement = staticmethod(enableElement)
    def initClass():
        """initClass()"""
        return _coin.SoGetMatrixAction_initClass()

    initClass = staticmethod(initClass)
    def __init__(self, *args): 
        """__init__(self, SbViewportRegion region) -> SoGetMatrixAction"""
        this = _coin.new_SoGetMatrixAction(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoGetMatrixAction
    __del__ = lambda self : None;
    def setViewportRegion(self, *args):
        """setViewportRegion(self, SbViewportRegion region)"""
        return _coin.SoGetMatrixAction_setViewportRegion(self, *args)

    def getViewportRegion(self):
        """getViewportRegion(self) -> SbViewportRegion"""
        return _coin.SoGetMatrixAction_getViewportRegion(self)

    def getMatrix(self):
        """getMatrix(self) -> SbMatrix"""
        return _coin.SoGetMatrixAction_getMatrix(self)

    def getInverse(self):
        """getInverse(self) -> SbMatrix"""
        return _coin.SoGetMatrixAction_getInverse(self)

    def getTextureMatrix(self):
        """getTextureMatrix(self) -> SbMatrix"""
        return _coin.SoGetMatrixAction_getTextureMatrix(self)

    def getTextureInverse(self):
        """getTextureInverse(self) -> SbMatrix"""
        return _coin.SoGetMatrixAction_getTextureInverse(self)

SoGetMatrixAction_swigregister = _coin.SoGetMatrixAction_swigregister
SoGetMatrixAction_swigregister(SoGetMatrixAction)

def SoGetMatrixAction_getClassTypeId():
  """SoGetMatrixAction_getClassTypeId() -> SoType"""
  return _coin.SoGetMatrixAction_getClassTypeId()

def SoGetMatrixAction_addMethod(*args):
  """SoGetMatrixAction_addMethod(SoType type, SoActionMethod method)"""
  return _coin.SoGetMatrixAction_addMethod(*args)

def SoGetMatrixAction_enableElement(*args):
  """SoGetMatrixAction_enableElement(SoType type, int stackindex)"""
  return _coin.SoGetMatrixAction_enableElement(*args)

def SoGetMatrixAction_initClass():
  """SoGetMatrixAction_initClass()"""
  return _coin.SoGetMatrixAction_initClass()

class SoGetPrimitiveCountAction(SoAction):
    """Proxy of C++ SoGetPrimitiveCountAction class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoGetPrimitiveCountAction_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGetPrimitiveCountAction_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def addMethod(*args):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoGetPrimitiveCountAction_addMethod(*args)

    addMethod = staticmethod(addMethod)
    def enableElement(*args):
        """enableElement(SoType type, int stackindex)"""
        return _coin.SoGetPrimitiveCountAction_enableElement(*args)

    enableElement = staticmethod(enableElement)
    def initClass():
        """initClass()"""
        return _coin.SoGetPrimitiveCountAction_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoGetPrimitiveCountAction"""
        this = _coin.new_SoGetPrimitiveCountAction()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoGetPrimitiveCountAction
    __del__ = lambda self : None;
    def getTriangleCount(self):
        """getTriangleCount(self) -> int"""
        return _coin.SoGetPrimitiveCountAction_getTriangleCount(self)

    def getLineCount(self):
        """getLineCount(self) -> int"""
        return _coin.SoGetPrimitiveCountAction_getLineCount(self)

    def getPointCount(self):
        """getPointCount(self) -> int"""
        return _coin.SoGetPrimitiveCountAction_getPointCount(self)

    def getTextCount(self):
        """getTextCount(self) -> int"""
        return _coin.SoGetPrimitiveCountAction_getTextCount(self)

    def getImageCount(self):
        """getImageCount(self) -> int"""
        return _coin.SoGetPrimitiveCountAction_getImageCount(self)

    def containsNoPrimitives(self):
        """containsNoPrimitives(self) -> SbBool"""
        return _coin.SoGetPrimitiveCountAction_containsNoPrimitives(self)

    def containsNonTriangleShapes(self):
        """containsNonTriangleShapes(self) -> SbBool"""
        return _coin.SoGetPrimitiveCountAction_containsNonTriangleShapes(self)

    def is3DTextCountedAsTriangles(self):
        """is3DTextCountedAsTriangles(self) -> SbBool"""
        return _coin.SoGetPrimitiveCountAction_is3DTextCountedAsTriangles(self)

    def setCount3DTextAsTriangles(self, *args):
        """setCount3DTextAsTriangles(self, SbBool flag)"""
        return _coin.SoGetPrimitiveCountAction_setCount3DTextAsTriangles(self, *args)

    def canApproximateCount(self):
        """canApproximateCount(self) -> SbBool"""
        return _coin.SoGetPrimitiveCountAction_canApproximateCount(self)

    def setCanApproximate(self, *args):
        """setCanApproximate(self, SbBool flag)"""
        return _coin.SoGetPrimitiveCountAction_setCanApproximate(self, *args)

    def setDecimationValue(self, *args):
        """
        setDecimationValue(self, Type type, float percentage = 1.0)
        setDecimationValue(self, Type type)
        """
        return _coin.SoGetPrimitiveCountAction_setDecimationValue(self, *args)

    def getDecimationType(self):
        """getDecimationType(self) -> Type"""
        return _coin.SoGetPrimitiveCountAction_getDecimationType(self)

    def getDecimationPercentage(self):
        """getDecimationPercentage(self) -> float"""
        return _coin.SoGetPrimitiveCountAction_getDecimationPercentage(self)

    def addNumTriangles(self, *args):
        """addNumTriangles(self, int num)"""
        return _coin.SoGetPrimitiveCountAction_addNumTriangles(self, *args)

    def addNumLines(self, *args):
        """addNumLines(self, int num)"""
        return _coin.SoGetPrimitiveCountAction_addNumLines(self, *args)

    def addNumPoints(self, *args):
        """addNumPoints(self, int num)"""
        return _coin.SoGetPrimitiveCountAction_addNumPoints(self, *args)

    def addNumText(self, *args):
        """addNumText(self, int num)"""
        return _coin.SoGetPrimitiveCountAction_addNumText(self, *args)

    def addNumImage(self, *args):
        """addNumImage(self, int num)"""
        return _coin.SoGetPrimitiveCountAction_addNumImage(self, *args)

    def incNumTriangles(self):
        """incNumTriangles(self)"""
        return _coin.SoGetPrimitiveCountAction_incNumTriangles(self)

    def incNumLines(self):
        """incNumLines(self)"""
        return _coin.SoGetPrimitiveCountAction_incNumLines(self)

    def incNumPoints(self):
        """incNumPoints(self)"""
        return _coin.SoGetPrimitiveCountAction_incNumPoints(self)

    def incNumText(self):
        """incNumText(self)"""
        return _coin.SoGetPrimitiveCountAction_incNumText(self)

    def incNumImage(self):
        """incNumImage(self)"""
        return _coin.SoGetPrimitiveCountAction_incNumImage(self)

SoGetPrimitiveCountAction_swigregister = _coin.SoGetPrimitiveCountAction_swigregister
SoGetPrimitiveCountAction_swigregister(SoGetPrimitiveCountAction)

def SoGetPrimitiveCountAction_getClassTypeId():
  """SoGetPrimitiveCountAction_getClassTypeId() -> SoType"""
  return _coin.SoGetPrimitiveCountAction_getClassTypeId()

def SoGetPrimitiveCountAction_addMethod(*args):
  """SoGetPrimitiveCountAction_addMethod(SoType type, SoActionMethod method)"""
  return _coin.SoGetPrimitiveCountAction_addMethod(*args)

def SoGetPrimitiveCountAction_enableElement(*args):
  """SoGetPrimitiveCountAction_enableElement(SoType type, int stackindex)"""
  return _coin.SoGetPrimitiveCountAction_enableElement(*args)

def SoGetPrimitiveCountAction_initClass():
  """SoGetPrimitiveCountAction_initClass()"""
  return _coin.SoGetPrimitiveCountAction_initClass()

class SoHandleEventAction(SoAction):
    """Proxy of C++ SoHandleEventAction class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoHandleEventAction_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoHandleEventAction_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def addMethod(*args):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoHandleEventAction_addMethod(*args)

    addMethod = staticmethod(addMethod)
    def enableElement(*args):
        """enableElement(SoType type, int stackindex)"""
        return _coin.SoHandleEventAction_enableElement(*args)

    enableElement = staticmethod(enableElement)
    def initClass():
        """initClass()"""
        return _coin.SoHandleEventAction_initClass()

    initClass = staticmethod(initClass)
    def __init__(self, *args): 
        """__init__(self, SbViewportRegion viewportregion) -> SoHandleEventAction"""
        this = _coin.new_SoHandleEventAction(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoHandleEventAction
    __del__ = lambda self : None;
    def setViewportRegion(self, *args):
        """setViewportRegion(self, SbViewportRegion newregion)"""
        return _coin.SoHandleEventAction_setViewportRegion(self, *args)

    def getViewportRegion(self):
        """getViewportRegion(self) -> SbViewportRegion"""
        return _coin.SoHandleEventAction_getViewportRegion(self)

    def setEvent(self, *args):
        """setEvent(self, SoEvent ev)"""
        return _coin.SoHandleEventAction_setEvent(self, *args)

    def getEvent(self):
        """getEvent(self) -> SoEvent"""
        return _coin.SoHandleEventAction_getEvent(self)

    def setHandled(self):
        """setHandled(self)"""
        return _coin.SoHandleEventAction_setHandled(self)

    def isHandled(self):
        """isHandled(self) -> SbBool"""
        return _coin.SoHandleEventAction_isHandled(self)

    def setGrabber(self, *args):
        """setGrabber(self, SoNode node)"""
        return _coin.SoHandleEventAction_setGrabber(self, *args)

    def releaseGrabber(self):
        """releaseGrabber(self)"""
        return _coin.SoHandleEventAction_releaseGrabber(self)

    def getGrabber(self):
        """getGrabber(self) -> SoNode"""
        return _coin.SoHandleEventAction_getGrabber(self)

    def setPickRoot(self, *args):
        """setPickRoot(self, SoNode node)"""
        return _coin.SoHandleEventAction_setPickRoot(self, *args)

    def getPickRoot(self):
        """getPickRoot(self) -> SoNode"""
        return _coin.SoHandleEventAction_getPickRoot(self)

    def setPickRadius(self, *args):
        """setPickRadius(self, float radiusinpixels)"""
        return _coin.SoHandleEventAction_setPickRadius(self, *args)

    def getPickedPoint(self):
        """getPickedPoint(self) -> SoPickedPoint"""
        return _coin.SoHandleEventAction_getPickedPoint(self)

    def getPickedPointList(self):
        """getPickedPointList(self) -> SoPickedPointList"""
        return _coin.SoHandleEventAction_getPickedPointList(self)

SoHandleEventAction_swigregister = _coin.SoHandleEventAction_swigregister
SoHandleEventAction_swigregister(SoHandleEventAction)

def SoHandleEventAction_getClassTypeId():
  """SoHandleEventAction_getClassTypeId() -> SoType"""
  return _coin.SoHandleEventAction_getClassTypeId()

def SoHandleEventAction_addMethod(*args):
  """SoHandleEventAction_addMethod(SoType type, SoActionMethod method)"""
  return _coin.SoHandleEventAction_addMethod(*args)

def SoHandleEventAction_enableElement(*args):
  """SoHandleEventAction_enableElement(SoType type, int stackindex)"""
  return _coin.SoHandleEventAction_enableElement(*args)

def SoHandleEventAction_initClass():
  """SoHandleEventAction_initClass()"""
  return _coin.SoHandleEventAction_initClass()

class SoPickAction(SoAction):
    """Proxy of C++ SoPickAction class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoPickAction_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoPickAction_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def addMethod(*args):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoPickAction_addMethod(*args)

    addMethod = staticmethod(addMethod)
    def enableElement(*args):
        """enableElement(SoType type, int stackindex)"""
        return _coin.SoPickAction_enableElement(*args)

    enableElement = staticmethod(enableElement)
    def initClass():
        """initClass()"""
        return _coin.SoPickAction_initClass()

    initClass = staticmethod(initClass)
    def setViewportRegion(self, *args):
        """setViewportRegion(self, SbViewportRegion newregion)"""
        return _coin.SoPickAction_setViewportRegion(self, *args)

    def getViewportRegion(self):
        """getViewportRegion(self) -> SbViewportRegion"""
        return _coin.SoPickAction_getViewportRegion(self)

    def enableCulling(self, *args):
        """enableCulling(self, SbBool flag)"""
        return _coin.SoPickAction_enableCulling(self, *args)

    def isCullingEnabled(self):
        """isCullingEnabled(self) -> SbBool"""
        return _coin.SoPickAction_isCullingEnabled(self)

SoPickAction_swigregister = _coin.SoPickAction_swigregister
SoPickAction_swigregister(SoPickAction)

def SoPickAction_getClassTypeId():
  """SoPickAction_getClassTypeId() -> SoType"""
  return _coin.SoPickAction_getClassTypeId()

def SoPickAction_addMethod(*args):
  """SoPickAction_addMethod(SoType type, SoActionMethod method)"""
  return _coin.SoPickAction_addMethod(*args)

def SoPickAction_enableElement(*args):
  """SoPickAction_enableElement(SoType type, int stackindex)"""
  return _coin.SoPickAction_enableElement(*args)

def SoPickAction_initClass():
  """SoPickAction_initClass()"""
  return _coin.SoPickAction_initClass()

class SoRayPickAction(SoPickAction):
    """Proxy of C++ SoRayPickAction class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoRayPickAction_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoRayPickAction_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def addMethod(*args):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoRayPickAction_addMethod(*args)

    addMethod = staticmethod(addMethod)
    def enableElement(*args):
        """enableElement(SoType type, int stackindex)"""
        return _coin.SoRayPickAction_enableElement(*args)

    enableElement = staticmethod(enableElement)
    def __init__(self, *args): 
        """__init__(self, SbViewportRegion viewportregion) -> SoRayPickAction"""
        this = _coin.new_SoRayPickAction(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoRayPickAction
    __del__ = lambda self : None;
    def initClass():
        """initClass()"""
        return _coin.SoRayPickAction_initClass()

    initClass = staticmethod(initClass)
    def setPoint(self, *args):
        """setPoint(self, SbVec2s viewportPoint)"""
        return _coin.SoRayPickAction_setPoint(self, *args)

    def setNormalizedPoint(self, *args):
        """setNormalizedPoint(self, SbVec2f normpoint)"""
        return _coin.SoRayPickAction_setNormalizedPoint(self, *args)

    def setRadius(self, *args):
        """setRadius(self, float radiusinpixels)"""
        return _coin.SoRayPickAction_setRadius(self, *args)

    def setRay(self, *args):
        """
        setRay(self, SbVec3f start, SbVec3f direction, float neardistance = -1.0, 
            float fardistance = -1.0)
        setRay(self, SbVec3f start, SbVec3f direction, float neardistance = -1.0)
        setRay(self, SbVec3f start, SbVec3f direction)
        """
        return _coin.SoRayPickAction_setRay(self, *args)

    def setPickAll(self, *args):
        """setPickAll(self, SbBool flag)"""
        return _coin.SoRayPickAction_setPickAll(self, *args)

    def isPickAll(self):
        """isPickAll(self) -> SbBool"""
        return _coin.SoRayPickAction_isPickAll(self)

    def getPickedPointList(self):
        """getPickedPointList(self) -> SoPickedPointList"""
        return _coin.SoRayPickAction_getPickedPointList(self)

    def getPickedPoint(self, index = 0):
        """
        getPickedPoint(self, int index = 0) -> SoPickedPoint
        getPickedPoint(self) -> SoPickedPoint
        """
        return _coin.SoRayPickAction_getPickedPoint(self, index)

    def computeWorldSpaceRay(self):
        """computeWorldSpaceRay(self)"""
        return _coin.SoRayPickAction_computeWorldSpaceRay(self)

    def hasWorldSpaceRay(self):
        """hasWorldSpaceRay(self) -> SbBool"""
        return _coin.SoRayPickAction_hasWorldSpaceRay(self)

    def setObjectSpace(self, *args):
        """
        setObjectSpace(self)
        setObjectSpace(self)
        """
        return _coin.SoRayPickAction_setObjectSpace(self, *args)

    def intersect(self, *args):
        """
        intersect(self, SbVec3f v0, SbVec3f v1, SbVec3f v2, SbVec3f intersection, 
            SbVec3f barycentric, SbBool front) -> SbBool
        intersect(self, SbVec3f v0, SbVec3f v1, SbVec3f intersection) -> SbBool
        intersect(self, SbVec3f point) -> SbBool
        intersect(self, SbBox3f box, SbBool usefullviewvolume = 1) -> SbBool
        intersect(self, SbBox3f box) -> SbBool
        intersect(self, SbBox3f box, SbVec3f intersection, SbBool usefullviewvolume = 1) -> SbBool
        intersect(self, SbBox3f box, SbVec3f intersection) -> SbBool
        """
        return _coin.SoRayPickAction_intersect(self, *args)

    def getViewVolume(self):
        """getViewVolume(self) -> SbViewVolume"""
        return _coin.SoRayPickAction_getViewVolume(self)

    def getLine(self):
        """getLine(self) -> SbLine"""
        return _coin.SoRayPickAction_getLine(self)

    def isBetweenPlanes(self, *args):
        """isBetweenPlanes(self, SbVec3f intersection) -> SbBool"""
        return _coin.SoRayPickAction_isBetweenPlanes(self, *args)

    def addIntersection(self, *args):
        """
        addIntersection(self, SbVec3f objectspacepoint, SbBool frontpick = 1) -> SoPickedPoint
        addIntersection(self, SbVec3f objectspacepoint) -> SoPickedPoint
        """
        return _coin.SoRayPickAction_addIntersection(self, *args)

    def reset(self):
        """reset(self)"""
        return _coin.SoRayPickAction_reset(self)

SoRayPickAction_swigregister = _coin.SoRayPickAction_swigregister
SoRayPickAction_swigregister(SoRayPickAction)

def SoRayPickAction_getClassTypeId():
  """SoRayPickAction_getClassTypeId() -> SoType"""
  return _coin.SoRayPickAction_getClassTypeId()

def SoRayPickAction_addMethod(*args):
  """SoRayPickAction_addMethod(SoType type, SoActionMethod method)"""
  return _coin.SoRayPickAction_addMethod(*args)

def SoRayPickAction_enableElement(*args):
  """SoRayPickAction_enableElement(SoType type, int stackindex)"""
  return _coin.SoRayPickAction_enableElement(*args)

def SoRayPickAction_initClass():
  """SoRayPickAction_initClass()"""
  return _coin.SoRayPickAction_initClass()

class SoSearchAction(SoAction):
    """Proxy of C++ SoSearchAction class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSearchAction_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSearchAction_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def addMethod(*args):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoSearchAction_addMethod(*args)

    addMethod = staticmethod(addMethod)
    def enableElement(*args):
        """enableElement(SoType type, int stackindex)"""
        return _coin.SoSearchAction_enableElement(*args)

    enableElement = staticmethod(enableElement)
    def initClass():
        """initClass()"""
        return _coin.SoSearchAction_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoSearchAction"""
        this = _coin.new_SoSearchAction()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSearchAction
    __del__ = lambda self : None;
    NODE = _coin.SoSearchAction_NODE
    TYPE = _coin.SoSearchAction_TYPE
    NAME = _coin.SoSearchAction_NAME
    FIRST = _coin.SoSearchAction_FIRST
    LAST = _coin.SoSearchAction_LAST
    ALL = _coin.SoSearchAction_ALL
    def setNode(self, *args):
        """setNode(self, SoNode node)"""
        return _coin.SoSearchAction_setNode(self, *args)

    def getNode(self):
        """getNode(self) -> SoNode"""
        return _coin.SoSearchAction_getNode(self)

    def setType(self, *args):
        """
        setType(self, SoType type, SbBool chkderived = 1)
        setType(self, SoType type)
        """
        return _coin.SoSearchAction_setType(self, *args)

    def getType(self, *args):
        """getType(self, SbBool chkderived) -> SoType"""
        return _coin.SoSearchAction_getType(self, *args)

    def setName(self, *args):
        """setName(self, SbName name)"""
        return _coin.SoSearchAction_setName(self, *args)

    def getName(self):
        """getName(self) -> SbName"""
        return _coin.SoSearchAction_getName(self)

    def setFind(self, *args):
        """setFind(self, int what)"""
        return _coin.SoSearchAction_setFind(self, *args)

    def getFind(self):
        """getFind(self) -> int"""
        return _coin.SoSearchAction_getFind(self)

    def setInterest(self, *args):
        """setInterest(self, Interest interest)"""
        return _coin.SoSearchAction_setInterest(self, *args)

    def getInterest(self):
        """getInterest(self) -> Interest"""
        return _coin.SoSearchAction_getInterest(self)

    def setSearchingAll(self, *args):
        """setSearchingAll(self, SbBool searchall)"""
        return _coin.SoSearchAction_setSearchingAll(self, *args)

    def isSearchingAll(self):
        """isSearchingAll(self) -> SbBool"""
        return _coin.SoSearchAction_isSearchingAll(self)

    def getPath(self):
        """getPath(self) -> SoPath"""
        return _coin.SoSearchAction_getPath(self)

    def getPaths(self):
        """getPaths(self) -> SoPathList"""
        return _coin.SoSearchAction_getPaths(self)

    def reset(self):
        """reset(self)"""
        return _coin.SoSearchAction_reset(self)

    def setFound(self):
        """setFound(self)"""
        return _coin.SoSearchAction_setFound(self)

    def isFound(self):
        """isFound(self) -> SbBool"""
        return _coin.SoSearchAction_isFound(self)

    def addPath(self, *args):
        """addPath(self, SoPath path)"""
        return _coin.SoSearchAction_addPath(self, *args)

    duringSearchAll = _swig_property(_coin.SoSearchAction_duringSearchAll_get, _coin.SoSearchAction_duringSearchAll_set)
SoSearchAction_swigregister = _coin.SoSearchAction_swigregister
SoSearchAction_swigregister(SoSearchAction)

def SoSearchAction_getClassTypeId():
  """SoSearchAction_getClassTypeId() -> SoType"""
  return _coin.SoSearchAction_getClassTypeId()

def SoSearchAction_addMethod(*args):
  """SoSearchAction_addMethod(SoType type, SoActionMethod method)"""
  return _coin.SoSearchAction_addMethod(*args)

def SoSearchAction_enableElement(*args):
  """SoSearchAction_enableElement(SoType type, int stackindex)"""
  return _coin.SoSearchAction_enableElement(*args)

def SoSearchAction_initClass():
  """SoSearchAction_initClass()"""
  return _coin.SoSearchAction_initClass()
cvar = _coin.cvar

class SoSimplifyAction(SoAction):
    """Proxy of C++ SoSimplifyAction class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSimplifyAction_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSimplifyAction_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def addMethod(*args):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoSimplifyAction_addMethod(*args)

    addMethod = staticmethod(addMethod)
    def enableElement(*args):
        """enableElement(SoType type, int stackindex)"""
        return _coin.SoSimplifyAction_enableElement(*args)

    enableElement = staticmethod(enableElement)
    def initClass():
        """initClass()"""
        return _coin.SoSimplifyAction_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoSimplifyAction"""
        this = _coin.new_SoSimplifyAction()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSimplifyAction
    __del__ = lambda self : None;
    def apply(self, *args):
        """
        apply(self, SoNode root)
        apply(self, SoPath path)
        apply(self, SoPathList pathlist, SbBool obeysrules = 0)
        apply(self, SoPathList pathlist)
        """
        return _coin.SoSimplifyAction_apply(self, *args)

SoSimplifyAction_swigregister = _coin.SoSimplifyAction_swigregister
SoSimplifyAction_swigregister(SoSimplifyAction)

def SoSimplifyAction_getClassTypeId():
  """SoSimplifyAction_getClassTypeId() -> SoType"""
  return _coin.SoSimplifyAction_getClassTypeId()

def SoSimplifyAction_addMethod(*args):
  """SoSimplifyAction_addMethod(SoType type, SoActionMethod method)"""
  return _coin.SoSimplifyAction_addMethod(*args)

def SoSimplifyAction_enableElement(*args):
  """SoSimplifyAction_enableElement(SoType type, int stackindex)"""
  return _coin.SoSimplifyAction_enableElement(*args)

def SoSimplifyAction_initClass():
  """SoSimplifyAction_initClass()"""
  return _coin.SoSimplifyAction_initClass()

class SoReorganizeAction(SoSimplifyAction):
    """Proxy of C++ SoReorganizeAction class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoReorganizeAction_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoReorganizeAction_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def addMethod(*args):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoReorganizeAction_addMethod(*args)

    addMethod = staticmethod(addMethod)
    def enableElement(*args):
        """enableElement(SoType type, int stackindex)"""
        return _coin.SoReorganizeAction_enableElement(*args)

    enableElement = staticmethod(enableElement)
    def initClass():
        """initClass()"""
        return _coin.SoReorganizeAction_initClass()

    initClass = staticmethod(initClass)
    def __init__(self, simplifier = None): 
        """
        __init__(self, SoSimplifier simplifier = None) -> SoReorganizeAction
        __init__(self) -> SoReorganizeAction
        """
        this = _coin.new_SoReorganizeAction(simplifier)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoReorganizeAction
    __del__ = lambda self : None;
    def getSimplifiedSceneGraph(self):
        """getSimplifiedSceneGraph(self) -> SoSeparator"""
        return _coin.SoReorganizeAction_getSimplifiedSceneGraph(self)

    def generateNormals(self, *args):
        """generateNormals(self, SbBool onoff)"""
        return _coin.SoReorganizeAction_generateNormals(self, *args)

    def areNormalGenerated(self):
        """areNormalGenerated(self) -> SbBool"""
        return _coin.SoReorganizeAction_areNormalGenerated(self)

    def generateTriangleStrips(self, *args):
        """generateTriangleStrips(self, SbBool onoff)"""
        return _coin.SoReorganizeAction_generateTriangleStrips(self, *args)

    def areTriangleStripGenerated(self):
        """areTriangleStripGenerated(self) -> SbBool"""
        return _coin.SoReorganizeAction_areTriangleStripGenerated(self)

    def generateTexCoords(self, *args):
        """generateTexCoords(self, SbBool onoff)"""
        return _coin.SoReorganizeAction_generateTexCoords(self, *args)

    def areTexCoordsGenerated(self):
        """areTexCoordsGenerated(self) -> SbBool"""
        return _coin.SoReorganizeAction_areTexCoordsGenerated(self)

    def generateVPNodes(self, *args):
        """generateVPNodes(self, SbBool onoff)"""
        return _coin.SoReorganizeAction_generateVPNodes(self, *args)

    def areVPNodesGenerated(self):
        """areVPNodesGenerated(self) -> SbBool"""
        return _coin.SoReorganizeAction_areVPNodesGenerated(self)

    def matchIndexArrays(self, *args):
        """matchIndexArrays(self, SbBool onoff)"""
        return _coin.SoReorganizeAction_matchIndexArrays(self, *args)

    def areIndexArraysMatched(self):
        """areIndexArraysMatched(self) -> SbBool"""
        return _coin.SoReorganizeAction_areIndexArraysMatched(self)

    def getSimplifier(self):
        """getSimplifier(self) -> SoSimplifier"""
        return _coin.SoReorganizeAction_getSimplifier(self)

    def apply(self, *args):
        """
        apply(self, SoNode root)
        apply(self, SoPath path)
        apply(self, SoPathList pathlist, SbBool obeysrules = 0)
        apply(self, SoPathList pathlist)
        """
        return _coin.SoReorganizeAction_apply(self, *args)

    def startReport(*args):
        """startReport(char msg)"""
        return _coin.SoReorganizeAction_startReport(*args)

    startReport = staticmethod(startReport)
    def finishReport():
        """finishReport()"""
        return _coin.SoReorganizeAction_finishReport()

    finishReport = staticmethod(finishReport)
SoReorganizeAction_swigregister = _coin.SoReorganizeAction_swigregister
SoReorganizeAction_swigregister(SoReorganizeAction)

def SoReorganizeAction_getClassTypeId():
  """SoReorganizeAction_getClassTypeId() -> SoType"""
  return _coin.SoReorganizeAction_getClassTypeId()

def SoReorganizeAction_addMethod(*args):
  """SoReorganizeAction_addMethod(SoType type, SoActionMethod method)"""
  return _coin.SoReorganizeAction_addMethod(*args)

def SoReorganizeAction_enableElement(*args):
  """SoReorganizeAction_enableElement(SoType type, int stackindex)"""
  return _coin.SoReorganizeAction_enableElement(*args)

def SoReorganizeAction_initClass():
  """SoReorganizeAction_initClass()"""
  return _coin.SoReorganizeAction_initClass()

def SoReorganizeAction_startReport(*args):
  """SoReorganizeAction_startReport(char msg)"""
  return _coin.SoReorganizeAction_startReport(*args)

def SoReorganizeAction_finishReport():
  """SoReorganizeAction_finishReport()"""
  return _coin.SoReorganizeAction_finishReport()

class SoWriteAction(SoAction):
    """Proxy of C++ SoWriteAction class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoWriteAction_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoWriteAction_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def addMethod(*args):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoWriteAction_addMethod(*args)

    addMethod = staticmethod(addMethod)
    def enableElement(*args):
        """enableElement(SoType type, int stackindex)"""
        return _coin.SoWriteAction_enableElement(*args)

    enableElement = staticmethod(enableElement)
    def __init__(self, *args): 
        """
        __init__(self) -> SoWriteAction
        __init__(self, SoOutput out) -> SoWriteAction
        """
        this = _coin.new_SoWriteAction(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoWriteAction
    __del__ = lambda self : None;
    def initClass():
        """initClass()"""
        return _coin.SoWriteAction_initClass()

    initClass = staticmethod(initClass)
    def getOutput(self):
        """getOutput(self) -> SoOutput"""
        return _coin.SoWriteAction_getOutput(self)

    def continueToApply(self, *args):
        """
        continueToApply(self, SoNode node)
        continueToApply(self, SoPath path)
        """
        return _coin.SoWriteAction_continueToApply(self, *args)

SoWriteAction_swigregister = _coin.SoWriteAction_swigregister
SoWriteAction_swigregister(SoWriteAction)

def SoWriteAction_getClassTypeId():
  """SoWriteAction_getClassTypeId() -> SoType"""
  return _coin.SoWriteAction_getClassTypeId()

def SoWriteAction_addMethod(*args):
  """SoWriteAction_addMethod(SoType type, SoActionMethod method)"""
  return _coin.SoWriteAction_addMethod(*args)

def SoWriteAction_enableElement(*args):
  """SoWriteAction_enableElement(SoType type, int stackindex)"""
  return _coin.SoWriteAction_enableElement(*args)

def SoWriteAction_initClass():
  """SoWriteAction_initClass()"""
  return _coin.SoWriteAction_initClass()

class SoAudioRenderAction(SoAction):
    """Proxy of C++ SoAudioRenderAction class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoAudioRenderAction_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoAudioRenderAction_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def addMethod(*args):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoAudioRenderAction_addMethod(*args)

    addMethod = staticmethod(addMethod)
    def enableElement(*args):
        """enableElement(SoType type, int stackindex)"""
        return _coin.SoAudioRenderAction_enableElement(*args)

    enableElement = staticmethod(enableElement)
    def initClass():
        """initClass()"""
        return _coin.SoAudioRenderAction_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoAudioRenderAction"""
        this = _coin.new_SoAudioRenderAction()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoAudioRenderAction
    __del__ = lambda self : None;
    def callDoAction(*args):
        """callDoAction(SoAction action, SoNode node)"""
        return _coin.SoAudioRenderAction_callDoAction(*args)

    callDoAction = staticmethod(callDoAction)
    def callAudioRender(*args):
        """callAudioRender(SoAction action, SoNode node)"""
        return _coin.SoAudioRenderAction_callAudioRender(*args)

    callAudioRender = staticmethod(callAudioRender)
SoAudioRenderAction_swigregister = _coin.SoAudioRenderAction_swigregister
SoAudioRenderAction_swigregister(SoAudioRenderAction)

def SoAudioRenderAction_getClassTypeId():
  """SoAudioRenderAction_getClassTypeId() -> SoType"""
  return _coin.SoAudioRenderAction_getClassTypeId()

def SoAudioRenderAction_addMethod(*args):
  """SoAudioRenderAction_addMethod(SoType type, SoActionMethod method)"""
  return _coin.SoAudioRenderAction_addMethod(*args)

def SoAudioRenderAction_enableElement(*args):
  """SoAudioRenderAction_enableElement(SoType type, int stackindex)"""
  return _coin.SoAudioRenderAction_enableElement(*args)

def SoAudioRenderAction_initClass():
  """SoAudioRenderAction_initClass()"""
  return _coin.SoAudioRenderAction_initClass()

def SoAudioRenderAction_callDoAction(*args):
  """SoAudioRenderAction_callDoAction(SoAction action, SoNode node)"""
  return _coin.SoAudioRenderAction_callDoAction(*args)

def SoAudioRenderAction_callAudioRender(*args):
  """SoAudioRenderAction_callAudioRender(SoAction action, SoNode node)"""
  return _coin.SoAudioRenderAction_callAudioRender(*args)

class SoIntersectingPrimitive(object):
    """Proxy of C++ SoIntersectingPrimitive class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    path = _swig_property(_coin.SoIntersectingPrimitive_path_get, _coin.SoIntersectingPrimitive_path_set)
    SEGMENT = _coin.SoIntersectingPrimitive_SEGMENT
    LINE_SEGMENT = _coin.SoIntersectingPrimitive_LINE_SEGMENT
    TRIANGLE = _coin.SoIntersectingPrimitive_TRIANGLE
    type = _swig_property(_coin.SoIntersectingPrimitive_type_get, _coin.SoIntersectingPrimitive_type_set)
    vertex = _swig_property(_coin.SoIntersectingPrimitive_vertex_get, _coin.SoIntersectingPrimitive_vertex_set)
    xf_vertex = _swig_property(_coin.SoIntersectingPrimitive_xf_vertex_get, _coin.SoIntersectingPrimitive_xf_vertex_set)
    def __init__(self): 
        """__init__(self) -> SoIntersectingPrimitive"""
        this = _coin.new_SoIntersectingPrimitive()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoIntersectingPrimitive
    __del__ = lambda self : None;
SoIntersectingPrimitive_swigregister = _coin.SoIntersectingPrimitive_swigregister
SoIntersectingPrimitive_swigregister(SoIntersectingPrimitive)

class SoIntersectionDetectionAction(SoAction):
    """Proxy of C++ SoIntersectionDetectionAction class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoIntersectionDetectionAction_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoIntersectionDetectionAction_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def addMethod(*args):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoIntersectionDetectionAction_addMethod(*args)

    addMethod = staticmethod(addMethod)
    def enableElement(*args):
        """enableElement(SoType type, int stackindex)"""
        return _coin.SoIntersectionDetectionAction_enableElement(*args)

    enableElement = staticmethod(enableElement)
    def initClass():
        """initClass()"""
        return _coin.SoIntersectionDetectionAction_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoIntersectionDetectionAction"""
        this = _coin.new_SoIntersectionDetectionAction()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoIntersectionDetectionAction
    __del__ = lambda self : None;
    NEXT_PRIMITIVE = _coin.SoIntersectionDetectionAction_NEXT_PRIMITIVE
    NEXT_SHAPE = _coin.SoIntersectionDetectionAction_NEXT_SHAPE
    ABORT = _coin.SoIntersectionDetectionAction_ABORT
    def setIntersectionDetectionEpsilon(self, *args):
        """setIntersectionDetectionEpsilon(self, float epsilon)"""
        return _coin.SoIntersectionDetectionAction_setIntersectionDetectionEpsilon(self, *args)

    def getIntersectionDetectionEpsilon(self):
        """getIntersectionDetectionEpsilon(self) -> float"""
        return _coin.SoIntersectionDetectionAction_getIntersectionDetectionEpsilon(self)

    def setIntersectionEpsilon(*args):
        """setIntersectionEpsilon(float epsilon)"""
        return _coin.SoIntersectionDetectionAction_setIntersectionEpsilon(*args)

    setIntersectionEpsilon = staticmethod(setIntersectionEpsilon)
    def getIntersectionEpsilon():
        """getIntersectionEpsilon() -> float"""
        return _coin.SoIntersectionDetectionAction_getIntersectionEpsilon()

    getIntersectionEpsilon = staticmethod(getIntersectionEpsilon)
    def setTypeEnabled(self, *args):
        """setTypeEnabled(self, SoType type, SbBool enable)"""
        return _coin.SoIntersectionDetectionAction_setTypeEnabled(self, *args)

    def isTypeEnabled(self, *args):
        """
        isTypeEnabled(self, SoType type, SbBool checkgroups = 0) -> SbBool
        isTypeEnabled(self, SoType type) -> SbBool
        """
        return _coin.SoIntersectionDetectionAction_isTypeEnabled(self, *args)

    def setManipsEnabled(self, *args):
        """setManipsEnabled(self, SbBool enable)"""
        return _coin.SoIntersectionDetectionAction_setManipsEnabled(self, *args)

    def isManipsEnabled(self):
        """isManipsEnabled(self) -> SbBool"""
        return _coin.SoIntersectionDetectionAction_isManipsEnabled(self)

    def setDraggersEnabled(self, *args):
        """setDraggersEnabled(self, SbBool enable)"""
        return _coin.SoIntersectionDetectionAction_setDraggersEnabled(self, *args)

    def isDraggersEnabled(self):
        """isDraggersEnabled(self) -> SbBool"""
        return _coin.SoIntersectionDetectionAction_isDraggersEnabled(self)

    def setShapeInternalsEnabled(self, *args):
        """setShapeInternalsEnabled(self, SbBool enable)"""
        return _coin.SoIntersectionDetectionAction_setShapeInternalsEnabled(self, *args)

    def isShapeInternalsEnabled(self):
        """isShapeInternalsEnabled(self) -> SbBool"""
        return _coin.SoIntersectionDetectionAction_isShapeInternalsEnabled(self)

    def apply(self, *args):
        """
        apply(self, SoNode node)
        apply(self, SoPath path)
        apply(self, SoPathList paths, SbBool obeysRules = 0)
        apply(self, SoPathList paths)
        """
        return _coin.SoIntersectionDetectionAction_apply(self, *args)

    def addVisitationCallback(self, *args):
        """
        addVisitationCallback(self, SoType type, SoIntersectionVisitationCB cb, void closure)
        addVisitationCallback(self, SoType type, PyObject pyfunc, PyObject closure)
        """
        return _coin.SoIntersectionDetectionAction_addVisitationCallback(self, *args)

    def removeVisitationCallback(self, *args):
        """
        removeVisitationCallback(self, SoType type, SoIntersectionVisitationCB cb, void closure)
        removeVisitationCallback(self, SoType type, PyObject pyfunc, PyObject closure)
        """
        return _coin.SoIntersectionDetectionAction_removeVisitationCallback(self, *args)

    def setFilterCallback(self, *args):
        """
        setFilterCallback(self, SoIntersectionFilterCB cb, void closure = None)
        setFilterCallback(self, SoIntersectionFilterCB cb)
        setFilterCallback(self, PyObject pyfunc, PyObject closure = None)
        setFilterCallback(self, PyObject pyfunc)
        """
        return _coin.SoIntersectionDetectionAction_setFilterCallback(self, *args)

    def addIntersectionCallback(self, *args):
        """
        addIntersectionCallback(self, SoIntersectionCB cb, void closure = None)
        addIntersectionCallback(self, SoIntersectionCB cb)
        addIntersectionCallback(self, PyObject pyfunc, PyObject closure = None)
        addIntersectionCallback(self, PyObject pyfunc)
        """
        return _coin.SoIntersectionDetectionAction_addIntersectionCallback(self, *args)

    def removeIntersectionCallback(self, *args):
        """
        removeIntersectionCallback(self, SoIntersectionCB cb, void closure = None)
        removeIntersectionCallback(self, SoIntersectionCB cb)
        removeIntersectionCallback(self, PyObject pyfunc, PyObject closure = None)
        removeIntersectionCallback(self, PyObject pyfunc)
        """
        return _coin.SoIntersectionDetectionAction_removeIntersectionCallback(self, *args)

SoIntersectionDetectionAction_swigregister = _coin.SoIntersectionDetectionAction_swigregister
SoIntersectionDetectionAction_swigregister(SoIntersectionDetectionAction)

def SoIntersectionDetectionAction_getClassTypeId():
  """SoIntersectionDetectionAction_getClassTypeId() -> SoType"""
  return _coin.SoIntersectionDetectionAction_getClassTypeId()

def SoIntersectionDetectionAction_addMethod(*args):
  """SoIntersectionDetectionAction_addMethod(SoType type, SoActionMethod method)"""
  return _coin.SoIntersectionDetectionAction_addMethod(*args)

def SoIntersectionDetectionAction_enableElement(*args):
  """SoIntersectionDetectionAction_enableElement(SoType type, int stackindex)"""
  return _coin.SoIntersectionDetectionAction_enableElement(*args)

def SoIntersectionDetectionAction_initClass():
  """SoIntersectionDetectionAction_initClass()"""
  return _coin.SoIntersectionDetectionAction_initClass()

def SoIntersectionDetectionAction_setIntersectionEpsilon(*args):
  """SoIntersectionDetectionAction_setIntersectionEpsilon(float epsilon)"""
  return _coin.SoIntersectionDetectionAction_setIntersectionEpsilon(*args)

def SoIntersectionDetectionAction_getIntersectionEpsilon():
  """SoIntersectionDetectionAction_getIntersectionEpsilon() -> float"""
  return _coin.SoIntersectionDetectionAction_getIntersectionEpsilon()

class SoToVRMLAction(SoAction):
    """Proxy of C++ SoToVRMLAction class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoToVRMLAction_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoToVRMLAction_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def addMethod(*args):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoToVRMLAction_addMethod(*args)

    addMethod = staticmethod(addMethod)
    def enableElement(*args):
        """enableElement(SoType type, int stackindex)"""
        return _coin.SoToVRMLAction_enableElement(*args)

    enableElement = staticmethod(enableElement)
    def initClass():
        """initClass()"""
        return _coin.SoToVRMLAction_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoToVRMLAction"""
        this = _coin.new_SoToVRMLAction()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoToVRMLAction
    __del__ = lambda self : None;
    def apply(self, *args):
        """
        apply(self, SoNode node)
        apply(self, SoPath path)
        apply(self, SoPathList pathlist, SbBool obeysrules = 0)
        apply(self, SoPathList pathlist)
        """
        return _coin.SoToVRMLAction_apply(self, *args)

    def getVRMLSceneGraph(self):
        """getVRMLSceneGraph(self) -> SoNode"""
        return _coin.SoToVRMLAction_getVRMLSceneGraph(self)

    def expandSoFile(self, *args):
        """expandSoFile(self, SbBool flag)"""
        return _coin.SoToVRMLAction_expandSoFile(self, *args)

    def areSoFileExpanded(self):
        """areSoFileExpanded(self) -> SbBool"""
        return _coin.SoToVRMLAction_areSoFileExpanded(self)

    def setUrlName(self, *args):
        """setUrlName(self, SbString name)"""
        return _coin.SoToVRMLAction_setUrlName(self, *args)

    def getUrlName(self):
        """getUrlName(self) -> SbString"""
        return _coin.SoToVRMLAction_getUrlName(self)

    def writeTexCoords(self, *args):
        """writeTexCoords(self, SbBool flag)"""
        return _coin.SoToVRMLAction_writeTexCoords(self, *args)

    def areTexCoordWritten(self):
        """areTexCoordWritten(self) -> SbBool"""
        return _coin.SoToVRMLAction_areTexCoordWritten(self)

    def expandTexture2Node(self, *args):
        """expandTexture2Node(self, SbBool flag)"""
        return _coin.SoToVRMLAction_expandTexture2Node(self, *args)

    def areTexture2NodeExpanded(self):
        """areTexture2NodeExpanded(self) -> SbBool"""
        return _coin.SoToVRMLAction_areTexture2NodeExpanded(self)

    def keepUnknownNodes(self, *args):
        """keepUnknownNodes(self, SbBool flag)"""
        return _coin.SoToVRMLAction_keepUnknownNodes(self, *args)

    def areUnknownNodeKept(self):
        """areUnknownNodeKept(self) -> SbBool"""
        return _coin.SoToVRMLAction_areUnknownNodeKept(self)

    def convertInlineNodes(self, *args):
        """convertInlineNodes(self, SbBool flag)"""
        return _coin.SoToVRMLAction_convertInlineNodes(self, *args)

    def doConvertInlineNodes(self):
        """doConvertInlineNodes(self) -> SbBool"""
        return _coin.SoToVRMLAction_doConvertInlineNodes(self)

    def conditionalConversion(self, *args):
        """conditionalConversion(self, SbBool flag)"""
        return _coin.SoToVRMLAction_conditionalConversion(self, *args)

    def doConditionalConversion(self):
        """doConditionalConversion(self) -> SbBool"""
        return _coin.SoToVRMLAction_doConditionalConversion(self)

    def setVerbosity(self, *args):
        """setVerbosity(self, SbBool flag)"""
        return _coin.SoToVRMLAction_setVerbosity(self, *args)

    def isVerbose(self):
        """isVerbose(self) -> SbBool"""
        return _coin.SoToVRMLAction_isVerbose(self)

SoToVRMLAction_swigregister = _coin.SoToVRMLAction_swigregister
SoToVRMLAction_swigregister(SoToVRMLAction)

def SoToVRMLAction_getClassTypeId():
  """SoToVRMLAction_getClassTypeId() -> SoType"""
  return _coin.SoToVRMLAction_getClassTypeId()

def SoToVRMLAction_addMethod(*args):
  """SoToVRMLAction_addMethod(SoType type, SoActionMethod method)"""
  return _coin.SoToVRMLAction_addMethod(*args)

def SoToVRMLAction_enableElement(*args):
  """SoToVRMLAction_enableElement(SoType type, int stackindex)"""
  return _coin.SoToVRMLAction_enableElement(*args)

def SoToVRMLAction_initClass():
  """SoToVRMLAction_initClass()"""
  return _coin.SoToVRMLAction_initClass()

class SoToVRML2Action(SoToVRMLAction):
    """Proxy of C++ SoToVRML2Action class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoToVRML2Action_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoToVRML2Action_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def addMethod(*args):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoToVRML2Action_addMethod(*args)

    addMethod = staticmethod(addMethod)
    def enableElement(*args):
        """enableElement(SoType type, int stackindex)"""
        return _coin.SoToVRML2Action_enableElement(*args)

    enableElement = staticmethod(enableElement)
    def initClass():
        """initClass()"""
        return _coin.SoToVRML2Action_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoToVRML2Action"""
        this = _coin.new_SoToVRML2Action()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoToVRML2Action
    __del__ = lambda self : None;
    def apply(self, *args):
        """
        apply(self, SoNode node)
        apply(self, SoPath path)
        apply(self, SoPathList pathlist, SbBool obeysrules = 0)
        apply(self, SoPathList pathlist)
        """
        return _coin.SoToVRML2Action_apply(self, *args)

    def getVRML2SceneGraph(self):
        """getVRML2SceneGraph(self) -> SoVRMLGroup"""
        return _coin.SoToVRML2Action_getVRML2SceneGraph(self)

    def reuseAppearanceNodes(self, *args):
        """reuseAppearanceNodes(self, SbBool appearance)"""
        return _coin.SoToVRML2Action_reuseAppearanceNodes(self, *args)

    def doReuseAppearanceNodes(self):
        """doReuseAppearanceNodes(self) -> SbBool"""
        return _coin.SoToVRML2Action_doReuseAppearanceNodes(self)

    def reusePropertyNodes(self, *args):
        """reusePropertyNodes(self, SbBool property)"""
        return _coin.SoToVRML2Action_reusePropertyNodes(self, *args)

    def doReusePropertyNodes(self):
        """doReusePropertyNodes(self) -> SbBool"""
        return _coin.SoToVRML2Action_doReusePropertyNodes(self)

    def reuseGeometryNodes(self, *args):
        """reuseGeometryNodes(self, SbBool geometry)"""
        return _coin.SoToVRML2Action_reuseGeometryNodes(self, *args)

    def doReuseGeometryNodes(self):
        """doReuseGeometryNodes(self) -> SbBool"""
        return _coin.SoToVRML2Action_doReuseGeometryNodes(self)

SoToVRML2Action_swigregister = _coin.SoToVRML2Action_swigregister
SoToVRML2Action_swigregister(SoToVRML2Action)

def SoToVRML2Action_getClassTypeId():
  """SoToVRML2Action_getClassTypeId() -> SoType"""
  return _coin.SoToVRML2Action_getClassTypeId()

def SoToVRML2Action_addMethod(*args):
  """SoToVRML2Action_addMethod(SoType type, SoActionMethod method)"""
  return _coin.SoToVRML2Action_addMethod(*args)

def SoToVRML2Action_enableElement(*args):
  """SoToVRML2Action_enableElement(SoType type, int stackindex)"""
  return _coin.SoToVRML2Action_enableElement(*args)

def SoToVRML2Action_initClass():
  """SoToVRML2Action_initClass()"""
  return _coin.SoToVRML2Action_initClass()

class SoHardCopy(object):
    """Proxy of C++ SoHardCopy class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def init():
        """init()"""
        return _coin.SoHardCopy_init()

    init = staticmethod(init)
    def getProductName():
        """getProductName() -> char"""
        return _coin.SoHardCopy_getProductName()

    getProductName = staticmethod(getProductName)
    def getVersion():
        """getVersion() -> char"""
        return _coin.SoHardCopy_getVersion()

    getVersion = staticmethod(getVersion)
    def __init__(self): 
        """__init__(self) -> SoHardCopy"""
        this = _coin.new_SoHardCopy()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoHardCopy
    __del__ = lambda self : None;
SoHardCopy_swigregister = _coin.SoHardCopy_swigregister
SoHardCopy_swigregister(SoHardCopy)

def SoHardCopy_init():
  """SoHardCopy_init()"""
  return _coin.SoHardCopy_init()

def SoHardCopy_getProductName():
  """SoHardCopy_getProductName() -> char"""
  return _coin.SoHardCopy_getProductName()

def SoHardCopy_getVersion():
  """SoHardCopy_getVersion() -> char"""
  return _coin.SoHardCopy_getVersion()

class SoVectorOutput(object):
    """Proxy of C++ SoVectorOutput class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoVectorOutput"""
        this = _coin.new_SoVectorOutput()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoVectorOutput
    __del__ = lambda self : None;
    def openFile(self, *args):
        """openFile(self, char filename) -> SbBool"""
        return _coin.SoVectorOutput_openFile(self, *args)

    def closeFile(self):
        """closeFile(self)"""
        return _coin.SoVectorOutput_closeFile(self)

    def getFilePointer(self):
        """getFilePointer(self) -> FILE"""
        return _coin.SoVectorOutput_getFilePointer(self)

SoVectorOutput_swigregister = _coin.SoVectorOutput_swigregister
SoVectorOutput_swigregister(SoVectorOutput)

class SoPSVectorOutput(SoVectorOutput):
    """Proxy of C++ SoPSVectorOutput class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoPSVectorOutput"""
        this = _coin.new_SoPSVectorOutput()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoPSVectorOutput
    __del__ = lambda self : None;
    def setColored(self, flag = 1):
        """
        setColored(self, SbBool flag = 1)
        setColored(self)
        """
        return _coin.SoPSVectorOutput_setColored(self, flag)

    def getColored(self):
        """getColored(self) -> SbBool"""
        return _coin.SoPSVectorOutput_getColored(self)

SoPSVectorOutput_swigregister = _coin.SoPSVectorOutput_swigregister
SoPSVectorOutput_swigregister(SoPSVectorOutput)

class SoVectorizeAction(SoCallbackAction):
    """Proxy of C++ SoVectorizeAction class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVectorizeAction_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVectorizeAction_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def addMethod(*args):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoVectorizeAction_addMethod(*args)

    addMethod = staticmethod(addMethod)
    def enableElement(*args):
        """enableElement(SoType type, int stackindex)"""
        return _coin.SoVectorizeAction_enableElement(*args)

    enableElement = staticmethod(enableElement)
    __swig_destroy__ = _coin.delete_SoVectorizeAction
    __del__ = lambda self : None;
    def getOutput(self):
        """getOutput(self) -> SoVectorOutput"""
        return _coin.SoVectorizeAction_getOutput(self)

    def initClass():
        """initClass()"""
        return _coin.SoVectorizeAction_initClass()

    initClass = staticmethod(initClass)
    INCH = _coin.SoVectorizeAction_INCH
    MM = _coin.SoVectorizeAction_MM
    METER = _coin.SoVectorizeAction_METER
    PORTRAIT = _coin.SoVectorizeAction_PORTRAIT
    LANDSCAPE = _coin.SoVectorizeAction_LANDSCAPE
    A0 = _coin.SoVectorizeAction_A0
    A1 = _coin.SoVectorizeAction_A1
    A2 = _coin.SoVectorizeAction_A2
    A3 = _coin.SoVectorizeAction_A3
    A4 = _coin.SoVectorizeAction_A4
    A5 = _coin.SoVectorizeAction_A5
    A6 = _coin.SoVectorizeAction_A6
    A7 = _coin.SoVectorizeAction_A7
    A8 = _coin.SoVectorizeAction_A8
    A9 = _coin.SoVectorizeAction_A9
    A10 = _coin.SoVectorizeAction_A10
    def apply(self, *args):
        """
        apply(self, SoNode node)
        apply(self, SoPath path)
        apply(self, SoPathList pathlist, SbBool obeysrules = 0)
        apply(self, SoPathList pathlist)
        """
        return _coin.SoVectorizeAction_apply(self, *args)

    def beginStandardPage(self, *args):
        """
        beginStandardPage(self, PageSize pagesize, float border = 10.0)
        beginStandardPage(self, PageSize pagesize)
        """
        return _coin.SoVectorizeAction_beginStandardPage(self, *args)

    def beginPage(self, *args):
        """
        beginPage(self, SbVec2f startpagepos, SbVec2f pagesize, DimensionUnit u = MM)
        beginPage(self, SbVec2f startpagepos, SbVec2f pagesize)
        """
        return _coin.SoVectorizeAction_beginPage(self, *args)

    def endPage(self):
        """endPage(self)"""
        return _coin.SoVectorizeAction_endPage(self)

    def calibrate(self, *args):
        """calibrate(self, SbViewportRegion vp)"""
        return _coin.SoVectorizeAction_calibrate(self, *args)

    def beginViewport(self, *args):
        """
        beginViewport(self, SbVec2f startpos = SbVec2f(-1.0f, 1.0f), SbVec2f size = SbVec2f(-1.0f, -1.0f), 
            DimensionUnit u = MM)
        beginViewport(self, SbVec2f startpos = SbVec2f(-1.0f, 1.0f), SbVec2f size = SbVec2f(-1.0f, -1.0f))
        beginViewport(self, SbVec2f startpos = SbVec2f(-1.0f, 1.0f))
        beginViewport(self)
        """
        return _coin.SoVectorizeAction_beginViewport(self, *args)

    def endViewport(self):
        """endViewport(self)"""
        return _coin.SoVectorizeAction_endViewport(self)

    def setOrientation(self, *args):
        """setOrientation(self, Orientation o)"""
        return _coin.SoVectorizeAction_setOrientation(self, *args)

    def getOrientation(self):
        """getOrientation(self) -> Orientation"""
        return _coin.SoVectorizeAction_getOrientation(self)

    def setBackgroundColor(self, *args):
        """
        setBackgroundColor(self, SbBool bg, SbColor col = SbColor(0.0f, 0.0f, 0.0f))
        setBackgroundColor(self, SbBool bg)
        """
        return _coin.SoVectorizeAction_setBackgroundColor(self, *args)

    def getBackgroundColor(self, *args):
        """getBackgroundColor(self, SbColor col) -> SbBool"""
        return _coin.SoVectorizeAction_getBackgroundColor(self, *args)

    def setNominalWidth(self, *args):
        """
        setNominalWidth(self, float w, DimensionUnit u = MM)
        setNominalWidth(self, float w)
        """
        return _coin.SoVectorizeAction_setNominalWidth(self, *args)

    def getNominalWidth(self, *args):
        """
        getNominalWidth(self, DimensionUnit u = MM) -> float
        getNominalWidth(self) -> float
        """
        return _coin.SoVectorizeAction_getNominalWidth(self, *args)

    def setPixelImageSize(self, *args):
        """
        setPixelImageSize(self, float w, DimensionUnit u = MM)
        setPixelImageSize(self, float w)
        """
        return _coin.SoVectorizeAction_setPixelImageSize(self, *args)

    def getPixelImageSize(self, *args):
        """
        getPixelImageSize(self, DimensionUnit u = MM) -> float
        getPixelImageSize(self) -> float
        """
        return _coin.SoVectorizeAction_getPixelImageSize(self, *args)

    CIRCLE = _coin.SoVectorizeAction_CIRCLE
    SQUARE = _coin.SoVectorizeAction_SQUARE
    def setPointStyle(self, *args):
        """setPointStyle(self, PointStyle style)"""
        return _coin.SoVectorizeAction_setPointStyle(self, *args)

    def getPointStyle(self):
        """getPointStyle(self) -> PointStyle"""
        return _coin.SoVectorizeAction_getPointStyle(self)

    def getPageStartpos(self):
        """getPageStartpos(self) -> SbVec2f"""
        return _coin.SoVectorizeAction_getPageStartpos(self)

    def getPageSize(self):
        """getPageSize(self) -> SbVec2f"""
        return _coin.SoVectorizeAction_getPageSize(self)

    REVERSE_ONLY_BLACK_AND_WHITE = _coin.SoVectorizeAction_REVERSE_ONLY_BLACK_AND_WHITE
    AS_IS = _coin.SoVectorizeAction_AS_IS
    REVERSE = _coin.SoVectorizeAction_REVERSE
    NO_JOIN = _coin.SoVectorizeAction_NO_JOIN
    MITERED_JOIN = _coin.SoVectorizeAction_MITERED_JOIN
    MITERED_BEVELED_JOIN = _coin.SoVectorizeAction_MITERED_BEVELED_JOIN
    BEVELED_JOIN = _coin.SoVectorizeAction_BEVELED_JOIN
    TRIANGULAR_JOIN = _coin.SoVectorizeAction_TRIANGULAR_JOIN
    ROUNDED_JOIN = _coin.SoVectorizeAction_ROUNDED_JOIN
    BUTT_END = _coin.SoVectorizeAction_BUTT_END
    SQUARE_END = _coin.SoVectorizeAction_SQUARE_END
    TRIANGULAR_END = _coin.SoVectorizeAction_TRIANGULAR_END
    ROUND_END = _coin.SoVectorizeAction_ROUND_END
    NO_HLHSR = _coin.SoVectorizeAction_NO_HLHSR
    HLHSR_SIMPLE_PAINTER = _coin.SoVectorizeAction_HLHSR_SIMPLE_PAINTER
    HLHSR_PAINTER = _coin.SoVectorizeAction_HLHSR_PAINTER
    HLHSR_PAINTER_SURFACE_REMOVAL = _coin.SoVectorizeAction_HLHSR_PAINTER_SURFACE_REMOVAL
    HIDDEN_LINES_REMOVAL = _coin.SoVectorizeAction_HIDDEN_LINES_REMOVAL
    def setDrawingDimensions(self, *args):
        """
        setDrawingDimensions(self, SbVec2f d, DimensionUnit u = MM)
        setDrawingDimensions(self, SbVec2f d)
        setDrawingDimensions(self, float w, float h, DimensionUnit u = MM)
        setDrawingDimensions(self, float w, float h)
        """
        return _coin.SoVectorizeAction_setDrawingDimensions(self, *args)

    def getDrawingDimensions(self, *args):
        """
        getDrawingDimensions(self, DimensionUnit u = MM) -> SbVec2f
        getDrawingDimensions(self) -> SbVec2f
        """
        return _coin.SoVectorizeAction_getDrawingDimensions(self, *args)

    def setStartPosition(self, *args):
        """
        setStartPosition(self, SbVec2f p, DimensionUnit u = MM)
        setStartPosition(self, SbVec2f p)
        setStartPosition(self, float x, float y, DimensionUnit u = MM)
        setStartPosition(self, float x, float y)
        """
        return _coin.SoVectorizeAction_setStartPosition(self, *args)

    def getStartPosition(self, *args):
        """
        getStartPosition(self, DimensionUnit u = MM) -> SbVec2f
        getStartPosition(self) -> SbVec2f
        """
        return _coin.SoVectorizeAction_getStartPosition(self, *args)

    def setColorTranslationMethod(self, *args):
        """setColorTranslationMethod(self, ColorTranslationMethod method)"""
        return _coin.SoVectorizeAction_setColorTranslationMethod(self, *args)

    def getColorTranslationMethod(self):
        """getColorTranslationMethod(self) -> ColorTranslationMethod"""
        return _coin.SoVectorizeAction_getColorTranslationMethod(self)

    def setLineEndStyle(self, *args):
        """setLineEndStyle(self, EndLineStyle style)"""
        return _coin.SoVectorizeAction_setLineEndStyle(self, *args)

    def getLineEndStyle(self):
        """getLineEndStyle(self) -> EndLineStyle"""
        return _coin.SoVectorizeAction_getLineEndStyle(self)

    def setLineJoinsStyle(self, *args):
        """setLineJoinsStyle(self, JoinLineStyle style)"""
        return _coin.SoVectorizeAction_setLineJoinsStyle(self, *args)

    def getLineJoinsStyle(self):
        """getLineJoinsStyle(self) -> JoinLineStyle"""
        return _coin.SoVectorizeAction_getLineJoinsStyle(self)

    def setHLHSRMode(self, *args):
        """setHLHSRMode(self, HLHSRMode mode)"""
        return _coin.SoVectorizeAction_setHLHSRMode(self, *args)

    def getHLHSRMode(self):
        """getHLHSRMode(self) -> HLHSRMode"""
        return _coin.SoVectorizeAction_getHLHSRMode(self)

    def setBorder(self, *args):
        """
        setBorder(self, float width)
        setBorder(self, float width, SbColor color)
        """
        return _coin.SoVectorizeAction_setBorder(self, *args)

    def setMiterLimit(self, *args):
        """setMiterLimit(self, float limit)"""
        return _coin.SoVectorizeAction_setMiterLimit(self, *args)

    def getMiterLimit(self):
        """getMiterLimit(self) -> float"""
        return _coin.SoVectorizeAction_getMiterLimit(self)

    def setPenDescription(self, *args):
        """
        setPenDescription(self, int num_pens, SbColor colors = None, float widths = None, 
            DimensionUnit u = MM)
        setPenDescription(self, int num_pens, SbColor colors = None, float widths = None)
        setPenDescription(self, int num_pens, SbColor colors = None)
        setPenDescription(self, int num_pens)
        """
        return _coin.SoVectorizeAction_setPenDescription(self, *args)

    def getPenDescription(self, *args):
        """
        getPenDescription(self, SbColor colors, float widths, DimensionUnit u = MM)
        getPenDescription(self, SbColor colors, float widths)
        """
        return _coin.SoVectorizeAction_getPenDescription(self, *args)

    def getPenNum(self):
        """getPenNum(self) -> int"""
        return _coin.SoVectorizeAction_getPenNum(self)

    def setColorPriority(self, *args):
        """setColorPriority(self, SbBool priority)"""
        return _coin.SoVectorizeAction_setColorPriority(self, *args)

    def getColorPriority(self):
        """getColorPriority(self) -> SbBool"""
        return _coin.SoVectorizeAction_getColorPriority(self)

    def enableLighting(self, *args):
        """enableLighting(self, SbBool flag)"""
        return _coin.SoVectorizeAction_enableLighting(self, *args)

    def isLightingEnabled(self):
        """isLightingEnabled(self) -> SbBool"""
        return _coin.SoVectorizeAction_isLightingEnabled(self)

SoVectorizeAction_swigregister = _coin.SoVectorizeAction_swigregister
SoVectorizeAction_swigregister(SoVectorizeAction)

def SoVectorizeAction_getClassTypeId():
  """SoVectorizeAction_getClassTypeId() -> SoType"""
  return _coin.SoVectorizeAction_getClassTypeId()

def SoVectorizeAction_addMethod(*args):
  """SoVectorizeAction_addMethod(SoType type, SoActionMethod method)"""
  return _coin.SoVectorizeAction_addMethod(*args)

def SoVectorizeAction_enableElement(*args):
  """SoVectorizeAction_enableElement(SoType type, int stackindex)"""
  return _coin.SoVectorizeAction_enableElement(*args)

def SoVectorizeAction_initClass():
  """SoVectorizeAction_initClass()"""
  return _coin.SoVectorizeAction_initClass()

class SoShape(SoNode):
    """Proxy of C++ SoShape class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShape_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoShape_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoShape_initClass()

    initClass = staticmethod(initClass)
    TRIANGLE_STRIP = _coin.SoShape_TRIANGLE_STRIP
    TRIANGLE_FAN = _coin.SoShape_TRIANGLE_FAN
    TRIANGLES = _coin.SoShape_TRIANGLES
    POLYGON = _coin.SoShape_POLYGON
    QUADS = _coin.SoShape_QUADS
    QUAD_STRIP = _coin.SoShape_QUAD_STRIP
    POINTS = _coin.SoShape_POINTS
    LINES = _coin.SoShape_LINES
    LINE_STRIP = _coin.SoShape_LINE_STRIP
    def affectsState(self):
        """affectsState(self) -> SbBool"""
        return _coin.SoShape_affectsState(self)

    def notify(self, *args):
        """notify(self, SoNotList nl)"""
        return _coin.SoShape_notify(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoShape_getBoundingBox(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoShape_GLRender(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoShape_rayPick(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoShape_callback(self, *args)

    def computeBBox(self, *args):
        """computeBBox(self, SoAction action, SbBox3f box, SbVec3f center)"""
        return _coin.SoShape_computeBBox(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoShape_getPrimitiveCount(self, *args)

    def getScreenSize(*args):
        """getScreenSize(SoState state, SbBox3f boundingbox, SbVec2s rectsize)"""
        return _coin.SoShape_getScreenSize(*args)

    getScreenSize = staticmethod(getScreenSize)
    def getDecimatedComplexity(*args):
        """getDecimatedComplexity(SoState state, float complexity) -> float"""
        return _coin.SoShape_getDecimatedComplexity(*args)

    getDecimatedComplexity = staticmethod(getDecimatedComplexity)
    def getBoundingBoxCache(self):
        """getBoundingBoxCache(self) -> SoBoundingBoxCache"""
        return _coin.SoShape_getBoundingBoxCache(self)

SoShape_swigregister = _coin.SoShape_swigregister
SoShape_swigregister(SoShape)

def SoShape_getClassTypeId():
  """SoShape_getClassTypeId() -> SoType"""
  return _coin.SoShape_getClassTypeId()

def SoShape_initClass():
  """SoShape_initClass()"""
  return _coin.SoShape_initClass()

def SoShape_getScreenSize(*args):
  """SoShape_getScreenSize(SoState state, SbBox3f boundingbox, SbVec2s rectsize)"""
  return _coin.SoShape_getScreenSize(*args)

def SoShape_getDecimatedComplexity(*args):
  """SoShape_getDecimatedComplexity(SoState state, float complexity) -> float"""
  return _coin.SoShape_getDecimatedComplexity(*args)

class SoImage(SoShape):
    """Proxy of C++ SoImage class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoImage_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoImage_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoImage_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoImage"""
        this = _coin.new_SoImage()
        try: self.this.append(this)
        except: self.this = this
    BOTTOM = _coin.SoImage_BOTTOM
    HALF = _coin.SoImage_HALF
    TOP = _coin.SoImage_TOP
    LEFT = _coin.SoImage_LEFT
    CENTER = _coin.SoImage_CENTER
    RIGHT = _coin.SoImage_RIGHT
    width = _swig_property(_coin.SoImage_width_get, _coin.SoImage_width_set)
    height = _swig_property(_coin.SoImage_height_get, _coin.SoImage_height_set)
    vertAlignment = _swig_property(_coin.SoImage_vertAlignment_get, _coin.SoImage_vertAlignment_set)
    horAlignment = _swig_property(_coin.SoImage_horAlignment_get, _coin.SoImage_horAlignment_set)
    image = _swig_property(_coin.SoImage_image_get, _coin.SoImage_image_set)
    filename = _swig_property(_coin.SoImage_filename_get, _coin.SoImage_filename_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoImage_GLRender(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoImage_rayPick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoImage_getPrimitiveCount(self, *args)

SoImage_swigregister = _coin.SoImage_swigregister
SoImage_swigregister(SoImage)

def SoImage_getClassTypeId():
  """SoImage_getClassTypeId() -> SoType"""
  return _coin.SoImage_getClassTypeId()

def SoImage_initClass():
  """SoImage_initClass()"""
  return _coin.SoImage_initClass()

class SoVectorizePSAction(SoVectorizeAction):
    """Proxy of C++ SoVectorizePSAction class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVectorizePSAction_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVectorizePSAction_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def addMethod(*args):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoVectorizePSAction_addMethod(*args)

    addMethod = staticmethod(addMethod)
    def enableElement(*args):
        """enableElement(SoType type, int stackindex)"""
        return _coin.SoVectorizePSAction_enableElement(*args)

    enableElement = staticmethod(enableElement)
    def __init__(self): 
        """__init__(self) -> SoVectorizePSAction"""
        this = _coin.new_SoVectorizePSAction()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoVectorizePSAction
    __del__ = lambda self : None;
    def initClass():
        """initClass()"""
        return _coin.SoVectorizePSAction_initClass()

    initClass = staticmethod(initClass)
    def setDefault2DFont(self, *args):
        """setDefault2DFont(self, SbString fontname)"""
        return _coin.SoVectorizePSAction_setDefault2DFont(self, *args)

    def getDefault2DFont(self):
        """getDefault2DFont(self) -> SbString"""
        return _coin.SoVectorizePSAction_getDefault2DFont(self)

    def setGouraudThreshold(self, *args):
        """setGouraudThreshold(self, double eps)"""
        return _coin.SoVectorizePSAction_setGouraudThreshold(self, *args)

    def getOutput(self):
        """getOutput(self) -> SoPSVectorOutput"""
        return _coin.SoVectorizePSAction_getOutput(self)

    def getPSOutput(self):
        """getPSOutput(self) -> SoPSVectorOutput"""
        return _coin.SoVectorizePSAction_getPSOutput(self)

SoVectorizePSAction_swigregister = _coin.SoVectorizePSAction_swigregister
SoVectorizePSAction_swigregister(SoVectorizePSAction)

def SoVectorizePSAction_getClassTypeId():
  """SoVectorizePSAction_getClassTypeId() -> SoType"""
  return _coin.SoVectorizePSAction_getClassTypeId()

def SoVectorizePSAction_addMethod(*args):
  """SoVectorizePSAction_addMethod(SoType type, SoActionMethod method)"""
  return _coin.SoVectorizePSAction_addMethod(*args)

def SoVectorizePSAction_enableElement(*args):
  """SoVectorizePSAction_enableElement(SoType type, int stackindex)"""
  return _coin.SoVectorizePSAction_enableElement(*args)

def SoVectorizePSAction_initClass():
  """SoVectorizePSAction_initClass()"""
  return _coin.SoVectorizePSAction_initClass()

class SoBundle(object):
    """Proxy of C++ SoBundle class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
SoBundle_swigregister = _coin.SoBundle_swigregister
SoBundle_swigregister(SoBundle)

class SoMaterialBundle(SoBundle):
    """Proxy of C++ SoMaterialBundle class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, SoAction action) -> SoMaterialBundle"""
        this = _coin.new_SoMaterialBundle(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMaterialBundle
    __del__ = lambda self : None;
    def setUpMultiple(self):
        """setUpMultiple(self)"""
        return _coin.SoMaterialBundle_setUpMultiple(self)

    def sendFirst(self):
        """sendFirst(self)"""
        return _coin.SoMaterialBundle_sendFirst(self)

    def forceSend(self, *args):
        """forceSend(self, int index)"""
        return _coin.SoMaterialBundle_forceSend(self, *args)

    def isColorOnly(self):
        """isColorOnly(self) -> SbBool"""
        return _coin.SoMaterialBundle_isColorOnly(self)

    def send(self, *args):
        """send(self, int index, SbBool betweenbeginend)"""
        return _coin.SoMaterialBundle_send(self, *args)

SoMaterialBundle_swigregister = _coin.SoMaterialBundle_swigregister
SoMaterialBundle_swigregister(SoMaterialBundle)

class SbBSPTree(object):
    """Proxy of C++ SbBSPTree class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, maxnodepts = 64, initsize = 4): 
        """
        __init__(self, int maxnodepts = 64, int initsize = 4) -> SbBSPTree
        __init__(self, int maxnodepts = 64) -> SbBSPTree
        __init__(self) -> SbBSPTree
        """
        this = _coin.new_SbBSPTree(maxnodepts, initsize)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SbBSPTree
    __del__ = lambda self : None;
    def numPoints(self):
        """numPoints(self) -> int"""
        return _coin.SbBSPTree_numPoints(self)

    def getPoint(self, *args):
        """
        getPoint(self, int idx) -> SbVec3f
        getPoint(self, int idx, SbVec3f pt)
        """
        return _coin.SbBSPTree_getPoint(self, *args)

    def getUserData(self, *args):
        """getUserData(self, int idx) -> void"""
        return _coin.SbBSPTree_getUserData(self, *args)

    def setUserData(self, *args):
        """setUserData(self, int idx, void data)"""
        return _coin.SbBSPTree_setUserData(self, *args)

    def addPoint(self, *args):
        """
        addPoint(self, SbVec3f pt, void userdata = None) -> int
        addPoint(self, SbVec3f pt) -> int
        """
        return _coin.SbBSPTree_addPoint(self, *args)

    def removePoint(self, *args):
        """
        removePoint(self, SbVec3f pt) -> int
        removePoint(self, int idx)
        """
        return _coin.SbBSPTree_removePoint(self, *args)

    def findPoint(self, *args):
        """findPoint(self, SbVec3f pos) -> int"""
        return _coin.SbBSPTree_findPoint(self, *args)

    def clear(self, initsize = 4):
        """
        clear(self, int initsize = 4)
        clear(self)
        """
        return _coin.SbBSPTree_clear(self, initsize)

    def getBBox(self):
        """getBBox(self) -> SbBox3f"""
        return _coin.SbBSPTree_getBBox(self)

    def getPointsArrayPtr(self):
        """getPointsArrayPtr(self) -> SbVec3f"""
        return _coin.SbBSPTree_getPointsArrayPtr(self)

    def findPoints(self, *args):
        """
        findPoints(self, SbSphere sphere, SbIntList array)
        findPoints(self, SbSphere sphere, SbList<(int)> array)
        """
        return _coin.SbBSPTree_findPoints(self, *args)

    def findClosest(self, *args):
        """
        findClosest(self, SbVec3f pos) -> int
        findClosest(self, SbSphere sphere, SbIntList array) -> int
        findClosest(self, SbSphere sphere, SbList<(int)> array) -> int
        """
        return _coin.SbBSPTree_findClosest(self, *args)

SbBSPTree_swigregister = _coin.SbBSPTree_swigregister
SbBSPTree_swigregister(SbBSPTree)

class SoNormalGenerator(object):
    """Proxy of C++ SoNormalGenerator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, SbBool ccw, int approxVertices = 64) -> SoNormalGenerator
        __init__(self, SbBool ccw) -> SoNormalGenerator
        """
        this = _coin.new_SoNormalGenerator(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoNormalGenerator
    __del__ = lambda self : None;
    def reset(self, *args):
        """reset(self, SbBool ccw)"""
        return _coin.SoNormalGenerator_reset(self, *args)

    def beginPolygon(self):
        """beginPolygon(self)"""
        return _coin.SoNormalGenerator_beginPolygon(self)

    def polygonVertex(self, *args):
        """polygonVertex(self, SbVec3f v)"""
        return _coin.SoNormalGenerator_polygonVertex(self, *args)

    def endPolygon(self):
        """endPolygon(self)"""
        return _coin.SoNormalGenerator_endPolygon(self)

    def triangle(self, *args):
        """triangle(self, SbVec3f v0, SbVec3f v1, SbVec3f v2)"""
        return _coin.SoNormalGenerator_triangle(self, *args)

    def quad(self, *args):
        """quad(self, SbVec3f v0, SbVec3f v1, SbVec3f v2, SbVec3f v3)"""
        return _coin.SoNormalGenerator_quad(self, *args)

    def generate(self, *args):
        """
        generate(self, float creaseAngle, int32_t striplens = None, int numstrips = 0)
        generate(self, float creaseAngle, int32_t striplens = None)
        generate(self, float creaseAngle)
        """
        return _coin.SoNormalGenerator_generate(self, *args)

    def generatePerStrip(self, *args):
        """generatePerStrip(self, int32_t striplens, int numstrips)"""
        return _coin.SoNormalGenerator_generatePerStrip(self, *args)

    def generatePerFace(self):
        """generatePerFace(self)"""
        return _coin.SoNormalGenerator_generatePerFace(self)

    def generateOverall(self):
        """generateOverall(self)"""
        return _coin.SoNormalGenerator_generateOverall(self)

    def getNumNormals(self):
        """getNumNormals(self) -> int"""
        return _coin.SoNormalGenerator_getNumNormals(self)

    def setNumNormals(self, *args):
        """setNumNormals(self, int num)"""
        return _coin.SoNormalGenerator_setNumNormals(self, *args)

    def getNormals(self):
        """getNormals(self) -> SbVec3f"""
        return _coin.SoNormalGenerator_getNormals(self)

    def getNormal(self, *args):
        """getNormal(self, int32_t i) -> SbVec3f"""
        return _coin.SoNormalGenerator_getNormal(self, *args)

    def setNormal(self, *args):
        """setNormal(self, int32_t index, SbVec3f normal)"""
        return _coin.SoNormalGenerator_setNormal(self, *args)

SoNormalGenerator_swigregister = _coin.SoNormalGenerator_swigregister
SoNormalGenerator_swigregister(SoNormalGenerator)

class SoNormalElement(SoReplacedElement):
    """Proxy of C++ SoNormalElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoNormalElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoNormalElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoNormalElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoNormalElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoNormalElement_init(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, int32_t numNormals, SbVec3f normals, 
            SbBool normalsAreUnitLength = 0)
        set(SoState state, SoNode node, int32_t numNormals, SbVec3f normals)
        """
        return _coin.SoNormalElement_set(*args)

    set = staticmethod(set)
    def getInstance(*args):
        """getInstance(SoState state) -> SoNormalElement"""
        return _coin.SoNormalElement_getInstance(*args)

    getInstance = staticmethod(getInstance)
    def getNum(self):
        """getNum(self) -> int32_t"""
        return _coin.SoNormalElement_getNum(self)

    def get(self, *args):
        """get(self, int index) -> SbVec3f"""
        return _coin.SoNormalElement_get(self, *args)

    def getArrayPtr(self):
        """getArrayPtr(self) -> SbVec3f"""
        return _coin.SoNormalElement_getArrayPtr(self)

    def areNormalsUnitLength(self):
        """areNormalsUnitLength(self) -> SbBool"""
        return _coin.SoNormalElement_areNormalsUnitLength(self)

SoNormalElement_swigregister = _coin.SoNormalElement_swigregister
SoNormalElement_swigregister(SoNormalElement)

def SoNormalElement_getClassTypeId():
  """SoNormalElement_getClassTypeId() -> SoType"""
  return _coin.SoNormalElement_getClassTypeId()

def SoNormalElement_getClassStackIndex():
  """SoNormalElement_getClassStackIndex() -> int"""
  return _coin.SoNormalElement_getClassStackIndex()

def SoNormalElement_createInstance():
  """SoNormalElement_createInstance() -> void"""
  return _coin.SoNormalElement_createInstance()

def SoNormalElement_initClass():
  """SoNormalElement_initClass()"""
  return _coin.SoNormalElement_initClass()

def SoNormalElement_set(*args):
  """
    set(SoState state, SoNode node, int32_t numNormals, SbVec3f normals, 
        SbBool normalsAreUnitLength = 0)
    SoNormalElement_set(SoState state, SoNode node, int32_t numNormals, SbVec3f normals)
    """
  return _coin.SoNormalElement_set(*args)

def SoNormalElement_getInstance(*args):
  """SoNormalElement_getInstance(SoState state) -> SoNormalElement"""
  return _coin.SoNormalElement_getInstance(*args)

class SoGLNormalElement(SoNormalElement):
    """Proxy of C++ SoGLNormalElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLNormalElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLNormalElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLNormalElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLNormalElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLNormalElement_init(self, *args)

    def send(self, *args):
        """send(self, int index)"""
        return _coin.SoGLNormalElement_send(self, *args)

SoGLNormalElement_swigregister = _coin.SoGLNormalElement_swigregister
SoGLNormalElement_swigregister(SoGLNormalElement)

def SoGLNormalElement_getClassTypeId():
  """SoGLNormalElement_getClassTypeId() -> SoType"""
  return _coin.SoGLNormalElement_getClassTypeId()

def SoGLNormalElement_getClassStackIndex():
  """SoGLNormalElement_getClassStackIndex() -> int"""
  return _coin.SoGLNormalElement_getClassStackIndex()

def SoGLNormalElement_createInstance():
  """SoGLNormalElement_createInstance() -> void"""
  return _coin.SoGLNormalElement_createInstance()

def SoGLNormalElement_initClass():
  """SoGLNormalElement_initClass()"""
  return _coin.SoGLNormalElement_initClass()

class SoNormalBundle(SoBundle):
    """Proxy of C++ SoNormalBundle class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    generator = _swig_property(_coin.SoNormalBundle_generator_get, _coin.SoNormalBundle_generator_set)
SoNormalBundle_swigregister = _coin.SoNormalBundle_swigregister
SoNormalBundle_swigregister(SoNormalBundle)

class SoTextureCoordinateElement(SoReplacedElement):
    """Proxy of C++ SoTextureCoordinateElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoTextureCoordinateElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoTextureCoordinateElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoTextureCoordinateElement_initClass()

    initClass = staticmethod(initClass)
    NONE = _coin.SoTextureCoordinateElement_NONE
    TEXGEN = _coin.SoTextureCoordinateElement_TEXGEN
    EXPLICIT = _coin.SoTextureCoordinateElement_EXPLICIT
    FUNCTION = _coin.SoTextureCoordinateElement_FUNCTION
    DEFAULT = _coin.SoTextureCoordinateElement_DEFAULT
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoTextureCoordinateElement_init(self, *args)

    def setDefault(*args):
        """setDefault(SoState state, SoNode node)"""
        return _coin.SoTextureCoordinateElement_setDefault(*args)

    setDefault = staticmethod(setDefault)
    def setFunction(*args):
        """
        setFunction(SoState state, SoNode node, SoTextureCoordinateFunctionCB func, 
            void userdata)
        """
        return _coin.SoTextureCoordinateElement_setFunction(*args)

    setFunction = staticmethod(setFunction)
    def set2(*args):
        """set2(SoState state, SoNode node, int32_t numCoords, SbVec2f coords)"""
        return _coin.SoTextureCoordinateElement_set2(*args)

    set2 = staticmethod(set2)
    def set3(*args):
        """set3(SoState state, SoNode node, int32_t numCoords, SbVec3f coords)"""
        return _coin.SoTextureCoordinateElement_set3(*args)

    set3 = staticmethod(set3)
    def set4(*args):
        """set4(SoState state, SoNode node, int32_t numCoords, SbVec4f coords)"""
        return _coin.SoTextureCoordinateElement_set4(*args)

    set4 = staticmethod(set4)
    def getType(self, *args):
        """
        getType(self, SoState state) -> CoordType
        getType(self) -> CoordType
        """
        return _coin.SoTextureCoordinateElement_getType(self, *args)

    def getInstance(*args):
        """getInstance(SoState state) -> SoTextureCoordinateElement"""
        return _coin.SoTextureCoordinateElement_getInstance(*args)

    getInstance = staticmethod(getInstance)
    def get(self, *args):
        """get(self, SbVec3f point, SbVec3f normal) -> SbVec4f"""
        return _coin.SoTextureCoordinateElement_get(self, *args)

    def getNum(self):
        """getNum(self) -> int32_t"""
        return _coin.SoTextureCoordinateElement_getNum(self)

    def is2D(self):
        """is2D(self) -> SbBool"""
        return _coin.SoTextureCoordinateElement_is2D(self)

    def getDimension(self):
        """getDimension(self) -> int32_t"""
        return _coin.SoTextureCoordinateElement_getDimension(self)

    def get2(self, *args):
        """get2(self, int index) -> SbVec2f"""
        return _coin.SoTextureCoordinateElement_get2(self, *args)

    def get3(self, *args):
        """get3(self, int index) -> SbVec3f"""
        return _coin.SoTextureCoordinateElement_get3(self, *args)

    def get4(self, *args):
        """get4(self, int index) -> SbVec4f"""
        return _coin.SoTextureCoordinateElement_get4(self, *args)

    def getArrayPtr2(self):
        """getArrayPtr2(self) -> SbVec2f"""
        return _coin.SoTextureCoordinateElement_getArrayPtr2(self)

    def getArrayPtr3(self):
        """getArrayPtr3(self) -> SbVec3f"""
        return _coin.SoTextureCoordinateElement_getArrayPtr3(self)

    def getArrayPtr4(self):
        """getArrayPtr4(self) -> SbVec4f"""
        return _coin.SoTextureCoordinateElement_getArrayPtr4(self)

SoTextureCoordinateElement_swigregister = _coin.SoTextureCoordinateElement_swigregister
SoTextureCoordinateElement_swigregister(SoTextureCoordinateElement)

def SoTextureCoordinateElement_getClassTypeId():
  """SoTextureCoordinateElement_getClassTypeId() -> SoType"""
  return _coin.SoTextureCoordinateElement_getClassTypeId()

def SoTextureCoordinateElement_getClassStackIndex():
  """SoTextureCoordinateElement_getClassStackIndex() -> int"""
  return _coin.SoTextureCoordinateElement_getClassStackIndex()

def SoTextureCoordinateElement_createInstance():
  """SoTextureCoordinateElement_createInstance() -> void"""
  return _coin.SoTextureCoordinateElement_createInstance()

def SoTextureCoordinateElement_initClass():
  """SoTextureCoordinateElement_initClass()"""
  return _coin.SoTextureCoordinateElement_initClass()

def SoTextureCoordinateElement_setDefault(*args):
  """SoTextureCoordinateElement_setDefault(SoState state, SoNode node)"""
  return _coin.SoTextureCoordinateElement_setDefault(*args)

def SoTextureCoordinateElement_setFunction(*args):
  """
    SoTextureCoordinateElement_setFunction(SoState state, SoNode node, SoTextureCoordinateFunctionCB func, 
        void userdata)
    """
  return _coin.SoTextureCoordinateElement_setFunction(*args)

def SoTextureCoordinateElement_set2(*args):
  """SoTextureCoordinateElement_set2(SoState state, SoNode node, int32_t numCoords, SbVec2f coords)"""
  return _coin.SoTextureCoordinateElement_set2(*args)

def SoTextureCoordinateElement_set3(*args):
  """SoTextureCoordinateElement_set3(SoState state, SoNode node, int32_t numCoords, SbVec3f coords)"""
  return _coin.SoTextureCoordinateElement_set3(*args)

def SoTextureCoordinateElement_set4(*args):
  """SoTextureCoordinateElement_set4(SoState state, SoNode node, int32_t numCoords, SbVec4f coords)"""
  return _coin.SoTextureCoordinateElement_set4(*args)

def SoTextureCoordinateElement_getInstance(*args):
  """SoTextureCoordinateElement_getInstance(SoState state) -> SoTextureCoordinateElement"""
  return _coin.SoTextureCoordinateElement_getInstance(*args)

class SoGLTextureCoordinateElement(SoTextureCoordinateElement):
    """Proxy of C++ SoGLTextureCoordinateElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLTextureCoordinateElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLTextureCoordinateElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLTextureCoordinateElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLTextureCoordinateElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLTextureCoordinateElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoGLTextureCoordinateElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLTextureCoordinateElement_pop(self, *args)

    def setTexGen(*args):
        """
        setTexGen(SoState state, SoNode node, SoTexCoordTexgenCB texgenFunc, 
            void texgenData = None, SoTextureCoordinateFunctionCB func = None, 
            void funcData = None)
        setTexGen(SoState state, SoNode node, SoTexCoordTexgenCB texgenFunc, 
            void texgenData = None, SoTextureCoordinateFunctionCB func = None)
        setTexGen(SoState state, SoNode node, SoTexCoordTexgenCB texgenFunc, 
            void texgenData = None)
        setTexGen(SoState state, SoNode node, SoTexCoordTexgenCB texgenFunc)
        """
        return _coin.SoGLTextureCoordinateElement_setTexGen(*args)

    setTexGen = staticmethod(setTexGen)
    def getType(self):
        """getType(self) -> CoordType"""
        return _coin.SoGLTextureCoordinateElement_getType(self)

    def getInstance(*args):
        """getInstance(SoState state) -> SoGLTextureCoordinateElement"""
        return _coin.SoGLTextureCoordinateElement_getInstance(*args)

    getInstance = staticmethod(getInstance)
    def send(self, *args):
        """
        send(self, int index)
        send(self, int index, SbVec3f c, SbVec3f n)
        """
        return _coin.SoGLTextureCoordinateElement_send(self, *args)

    def initMulti(self, *args):
        """initMulti(self, SoState state)"""
        return _coin.SoGLTextureCoordinateElement_initMulti(self, *args)

SoGLTextureCoordinateElement_swigregister = _coin.SoGLTextureCoordinateElement_swigregister
SoGLTextureCoordinateElement_swigregister(SoGLTextureCoordinateElement)

def SoGLTextureCoordinateElement_getClassTypeId():
  """SoGLTextureCoordinateElement_getClassTypeId() -> SoType"""
  return _coin.SoGLTextureCoordinateElement_getClassTypeId()

def SoGLTextureCoordinateElement_getClassStackIndex():
  """SoGLTextureCoordinateElement_getClassStackIndex() -> int"""
  return _coin.SoGLTextureCoordinateElement_getClassStackIndex()

def SoGLTextureCoordinateElement_createInstance():
  """SoGLTextureCoordinateElement_createInstance() -> void"""
  return _coin.SoGLTextureCoordinateElement_createInstance()

def SoGLTextureCoordinateElement_initClass():
  """SoGLTextureCoordinateElement_initClass()"""
  return _coin.SoGLTextureCoordinateElement_initClass()

def SoGLTextureCoordinateElement_setTexGen(*args):
  """
    setTexGen(SoState state, SoNode node, SoTexCoordTexgenCB texgenFunc, 
        void texgenData = None, SoTextureCoordinateFunctionCB func = None, 
        void funcData = None)
    setTexGen(SoState state, SoNode node, SoTexCoordTexgenCB texgenFunc, 
        void texgenData = None, SoTextureCoordinateFunctionCB func = None)
    setTexGen(SoState state, SoNode node, SoTexCoordTexgenCB texgenFunc, 
        void texgenData = None)
    SoGLTextureCoordinateElement_setTexGen(SoState state, SoNode node, SoTexCoordTexgenCB texgenFunc)
    """
  return _coin.SoGLTextureCoordinateElement_setTexGen(*args)

def SoGLTextureCoordinateElement_getInstance(*args):
  """SoGLTextureCoordinateElement_getInstance(SoState state) -> SoGLTextureCoordinateElement"""
  return _coin.SoGLTextureCoordinateElement_getInstance(*args)

class SoTextureCoordinateBundle(SoBundle):
    """Proxy of C++ SoTextureCoordinateBundle class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, SoAction action, SbBool forRendering, SbBool setUpDefault = 1) -> SoTextureCoordinateBundle
        __init__(self, SoAction action, SbBool forRendering) -> SoTextureCoordinateBundle
        """
        this = _coin.new_SoTextureCoordinateBundle(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoTextureCoordinateBundle
    __del__ = lambda self : None;
    def needCoordinates(self):
        """needCoordinates(self) -> SbBool"""
        return _coin.SoTextureCoordinateBundle_needCoordinates(self)

    def isFunction(self):
        """isFunction(self) -> SbBool"""
        return _coin.SoTextureCoordinateBundle_isFunction(self)

    def get(self, *args):
        """
        get(self, int index) -> SbVec4f
        get(self, SbVec3f point, SbVec3f normal) -> SbVec4f
        """
        return _coin.SoTextureCoordinateBundle_get(self, *args)

    def send(self, *args):
        """
        send(self, int index)
        send(self, int index, SbVec3f point, SbVec3f normal)
        """
        return _coin.SoTextureCoordinateBundle_send(self, *args)

    def needIndices(self):
        """needIndices(self) -> SbBool"""
        return _coin.SoTextureCoordinateBundle_needIndices(self)

SoTextureCoordinateBundle_swigregister = _coin.SoTextureCoordinateBundle_swigregister
SoTextureCoordinateBundle_swigregister(SoTextureCoordinateBundle)

class SoCache(object):
    """Proxy of C++ SoCache class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, SoState state) -> SoCache"""
        this = _coin.new_SoCache(*args)
        try: self.this.append(this)
        except: self.this = this
    def ref(self):
        """ref(self)"""
        return _coin.SoCache_ref(self)

    def unref(self, state = None):
        """
        unref(self, SoState state = None)
        unref(self)
        """
        return _coin.SoCache_unref(self, state)

    def addElement(self, *args):
        """addElement(self, SoElement elem)"""
        return _coin.SoCache_addElement(self, *args)

    def addCacheDependency(self, *args):
        """addCacheDependency(self, SoState state, SoCache cache)"""
        return _coin.SoCache_addCacheDependency(self, *args)

    def isValid(self, *args):
        """isValid(self, SoState state) -> SbBool"""
        return _coin.SoCache_isValid(self, *args)

    def getInvalidElement(self, *args):
        """getInvalidElement(self, SoState state) -> SoElement"""
        return _coin.SoCache_getInvalidElement(self, *args)

    def invalidate(self):
        """invalidate(self)"""
        return _coin.SoCache_invalidate(self)

SoCache_swigregister = _coin.SoCache_swigregister
SoCache_swigregister(SoCache)

class SoBoundingBoxCache(SoCache):
    """Proxy of C++ SoBoundingBoxCache class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, SoState state) -> SoBoundingBoxCache"""
        this = _coin.new_SoBoundingBoxCache(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoBoundingBoxCache
    __del__ = lambda self : None;
    def set(self, *args):
        """set(self, SbXfBox3f boundingbox, SbBool centerset, SbVec3f centerpoint)"""
        return _coin.SoBoundingBoxCache_set(self, *args)

    def getBox(self):
        """getBox(self) -> SbXfBox3f"""
        return _coin.SoBoundingBoxCache_getBox(self)

    def getProjectedBox(self):
        """getProjectedBox(self) -> SbBox3f"""
        return _coin.SoBoundingBoxCache_getProjectedBox(self)

    def isCenterSet(self):
        """isCenterSet(self) -> SbBool"""
        return _coin.SoBoundingBoxCache_isCenterSet(self)

    def getCenter(self):
        """getCenter(self) -> SbVec3f"""
        return _coin.SoBoundingBoxCache_getCenter(self)

    def setHasLinesOrPoints(*args):
        """setHasLinesOrPoints(SoState state)"""
        return _coin.SoBoundingBoxCache_setHasLinesOrPoints(*args)

    setHasLinesOrPoints = staticmethod(setHasLinesOrPoints)
    def hasLinesOrPoints(self):
        """hasLinesOrPoints(self) -> SbBool"""
        return _coin.SoBoundingBoxCache_hasLinesOrPoints(self)

SoBoundingBoxCache_swigregister = _coin.SoBoundingBoxCache_swigregister
SoBoundingBoxCache_swigregister(SoBoundingBoxCache)

def SoBoundingBoxCache_setHasLinesOrPoints(*args):
  """SoBoundingBoxCache_setHasLinesOrPoints(SoState state)"""
  return _coin.SoBoundingBoxCache_setHasLinesOrPoints(*args)

class SoConvexDataCache(SoCache):
    """Proxy of C++ SoConvexDataCache class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, SoState state) -> SoConvexDataCache"""
        this = _coin.new_SoConvexDataCache(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoConvexDataCache
    __del__ = lambda self : None;
    NONE = _coin.SoConvexDataCache_NONE
    PER_FACE = _coin.SoConvexDataCache_PER_FACE
    PER_FACE_INDEXED = _coin.SoConvexDataCache_PER_FACE_INDEXED
    PER_VERTEX = _coin.SoConvexDataCache_PER_VERTEX
    PER_VERTEX_INDEXED = _coin.SoConvexDataCache_PER_VERTEX_INDEXED
    def generate(self, *args):
        """
        generate(self, SoCoordinateElement coords, int32_t coordindices, int numcoordindices, 
            int32_t matindices, int32_t normindices, 
            int32_t texindices, Binding matbinding, 
            Binding normbinding, Binding texbinding)
        """
        return _coin.SoConvexDataCache_generate(self, *args)

    def getCoordIndices(self):
        """getCoordIndices(self) -> int32_t"""
        return _coin.SoConvexDataCache_getCoordIndices(self)

    def getNumCoordIndices(self):
        """getNumCoordIndices(self) -> int"""
        return _coin.SoConvexDataCache_getNumCoordIndices(self)

    def getMaterialIndices(self):
        """getMaterialIndices(self) -> int32_t"""
        return _coin.SoConvexDataCache_getMaterialIndices(self)

    def getNumMaterialIndices(self):
        """getNumMaterialIndices(self) -> int"""
        return _coin.SoConvexDataCache_getNumMaterialIndices(self)

    def getNormalIndices(self):
        """getNormalIndices(self) -> int32_t"""
        return _coin.SoConvexDataCache_getNormalIndices(self)

    def getNumNormalIndices(self):
        """getNumNormalIndices(self) -> int"""
        return _coin.SoConvexDataCache_getNumNormalIndices(self)

    def getTexIndices(self):
        """getTexIndices(self) -> int32_t"""
        return _coin.SoConvexDataCache_getTexIndices(self)

    def getNumTexIndices(self):
        """getNumTexIndices(self) -> int"""
        return _coin.SoConvexDataCache_getNumTexIndices(self)

SoConvexDataCache_swigregister = _coin.SoConvexDataCache_swigregister
SoConvexDataCache_swigregister(SoConvexDataCache)

class SoGLCacheList(object):
    """Proxy of C++ SoGLCacheList class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
SoGLCacheList_swigregister = _coin.SoGLCacheList_swigregister
SoGLCacheList_swigregister(SoGLCacheList)

class SoGLLazyElement(SoLazyElement):
    """Proxy of C++ SoGLLazyElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLLazyElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLLazyElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLLazyElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLLazyElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLLazyElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoGLLazyElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevtopelement)"""
        return _coin.SoGLLazyElement_pop(self, *args)

    def sendAllMaterial(*args):
        """sendAllMaterial(SoState state)"""
        return _coin.SoGLLazyElement_sendAllMaterial(*args)

    sendAllMaterial = staticmethod(sendAllMaterial)
    def sendNoMaterial(*args):
        """sendNoMaterial(SoState state)"""
        return _coin.SoGLLazyElement_sendNoMaterial(*args)

    sendNoMaterial = staticmethod(sendNoMaterial)
    def sendOnlyDiffuseColor(*args):
        """sendOnlyDiffuseColor(SoState state)"""
        return _coin.SoGLLazyElement_sendOnlyDiffuseColor(*args)

    sendOnlyDiffuseColor = staticmethod(sendOnlyDiffuseColor)
    def sendLightModel(*args):
        """sendLightModel(SoState state, int32_t model)"""
        return _coin.SoGLLazyElement_sendLightModel(*args)

    sendLightModel = staticmethod(sendLightModel)
    def sendPackedDiffuse(*args):
        """sendPackedDiffuse(SoState state, uint32_t diffuse)"""
        return _coin.SoGLLazyElement_sendPackedDiffuse(*args)

    sendPackedDiffuse = staticmethod(sendPackedDiffuse)
    def sendFlatshading(*args):
        """sendFlatshading(SoState state, SbBool onoff)"""
        return _coin.SoGLLazyElement_sendFlatshading(*args)

    sendFlatshading = staticmethod(sendFlatshading)
    def sendVertexOrdering(*args):
        """sendVertexOrdering(SoState state, VertexOrdering ordering)"""
        return _coin.SoGLLazyElement_sendVertexOrdering(*args)

    sendVertexOrdering = staticmethod(sendVertexOrdering)
    def sendTwosideLighting(*args):
        """sendTwosideLighting(SoState state, SbBool onoff)"""
        return _coin.SoGLLazyElement_sendTwosideLighting(*args)

    sendTwosideLighting = staticmethod(sendTwosideLighting)
    def sendBackfaceCulling(*args):
        """sendBackfaceCulling(SoState state, SbBool onoff)"""
        return _coin.SoGLLazyElement_sendBackfaceCulling(*args)

    sendBackfaceCulling = staticmethod(sendBackfaceCulling)
    def sendDiffuseByIndex(self, *args):
        """sendDiffuseByIndex(self, int index)"""
        return _coin.SoGLLazyElement_sendDiffuseByIndex(self, *args)

    def isColorIndex(*args):
        """isColorIndex(SoState state) -> SbBool"""
        return _coin.SoGLLazyElement_isColorIndex(*args)

    isColorIndex = staticmethod(isColorIndex)
    def getInstance(*args):
        """getInstance(SoState state) -> SoGLLazyElement"""
        return _coin.SoGLLazyElement_getInstance(*args)

    getInstance = staticmethod(getInstance)
    def send(self, *args):
        """send(self, SoState state, uint32_t mask)"""
        return _coin.SoGLLazyElement_send(self, *args)

    def sendVPPacked(self, *args):
        """sendVPPacked(self, SoState state, unsigned char pcolor)"""
        return _coin.SoGLLazyElement_sendVPPacked(self, *args)

    def reset(self, *args):
        """reset(self, SoState state, uint32_t bitmask)"""
        return _coin.SoGLLazyElement_reset(self, *args)

    def setDiffuseElt(self, *args):
        """setDiffuseElt(self, SoNode arg0, int32_t numcolors, SbColor colors, SoColorPacker packer)"""
        return _coin.SoGLLazyElement_setDiffuseElt(self, *args)

    def setPackedElt(self, *args):
        """setPackedElt(self, SoNode node, int32_t numcolors, uint32_t colors, SbBool packedtransparency)"""
        return _coin.SoGLLazyElement_setPackedElt(self, *args)

    def setColorIndexElt(self, *args):
        """setColorIndexElt(self, SoNode node, int32_t numindices, int32_t indices)"""
        return _coin.SoGLLazyElement_setColorIndexElt(self, *args)

    def setTranspElt(self, *args):
        """setTranspElt(self, SoNode node, int32_t numtransp, float transp, SoColorPacker packer)"""
        return _coin.SoGLLazyElement_setTranspElt(self, *args)

    def setTranspTypeElt(self, *args):
        """setTranspTypeElt(self, int32_t type)"""
        return _coin.SoGLLazyElement_setTranspTypeElt(self, *args)

    def setAmbientElt(self, *args):
        """setAmbientElt(self, SbColor color)"""
        return _coin.SoGLLazyElement_setAmbientElt(self, *args)

    def setEmissiveElt(self, *args):
        """setEmissiveElt(self, SbColor color)"""
        return _coin.SoGLLazyElement_setEmissiveElt(self, *args)

    def setSpecularElt(self, *args):
        """setSpecularElt(self, SbColor color)"""
        return _coin.SoGLLazyElement_setSpecularElt(self, *args)

    def setShininessElt(self, *args):
        """setShininessElt(self, float value)"""
        return _coin.SoGLLazyElement_setShininessElt(self, *args)

    def setColorMaterialElt(self, *args):
        """setColorMaterialElt(self, SbBool value)"""
        return _coin.SoGLLazyElement_setColorMaterialElt(self, *args)

    def enableBlendingElt(self, *args):
        """enableBlendingElt(self, int sfactor, int dfactor, int alpha_sfactor, int alpha_dfactor)"""
        return _coin.SoGLLazyElement_enableBlendingElt(self, *args)

    def disableBlendingElt(self):
        """disableBlendingElt(self)"""
        return _coin.SoGLLazyElement_disableBlendingElt(self)

    def setLightModelElt(self, *args):
        """setLightModelElt(self, SoState state, int32_t model)"""
        return _coin.SoGLLazyElement_setLightModelElt(self, *args)

    def setMaterialElt(self, *args):
        """
        setMaterialElt(self, SoNode node, uint32_t bitmask, SoColorPacker packer, 
            SbColor diffuse, int numdiffuse, float transp, 
            int numtransp, SbColor ambient, SbColor emissive, 
            SbColor specular, float shininess, SbBool istransparent)
        """
        return _coin.SoGLLazyElement_setMaterialElt(self, *args)

    def setVertexOrderingElt(self, *args):
        """setVertexOrderingElt(self, VertexOrdering ordering)"""
        return _coin.SoGLLazyElement_setVertexOrderingElt(self, *args)

    def setBackfaceCullingElt(self, *args):
        """setBackfaceCullingElt(self, SbBool onoff)"""
        return _coin.SoGLLazyElement_setBackfaceCullingElt(self, *args)

    def setTwosideLightingElt(self, *args):
        """setTwosideLightingElt(self, SbBool onoff)"""
        return _coin.SoGLLazyElement_setTwosideLightingElt(self, *args)

    def setShadeModelElt(self, *args):
        """setShadeModelElt(self, SbBool flatshading)"""
        return _coin.SoGLLazyElement_setShadeModelElt(self, *args)

    def setGLImageIdElt(self, *args):
        """setGLImageIdElt(self, uint32_t glimageid, SbBool alphatest)"""
        return _coin.SoGLLazyElement_setGLImageIdElt(self, *args)

    def setAlphaTestElt(self, *args):
        """setAlphaTestElt(self, SbBool onoff)"""
        return _coin.SoGLLazyElement_setAlphaTestElt(self, *args)

    def beginCaching(*args):
        """beginCaching(SoState state, GLState prestate, GLState poststate)"""
        return _coin.SoGLLazyElement_beginCaching(*args)

    beginCaching = staticmethod(beginCaching)
    def endCaching(*args):
        """endCaching(SoState state)"""
        return _coin.SoGLLazyElement_endCaching(*args)

    endCaching = staticmethod(endCaching)
    def preCacheCall(*args):
        """preCacheCall(SoState state, GLState prestate) -> SbBool"""
        return _coin.SoGLLazyElement_preCacheCall(*args)

    preCacheCall = staticmethod(preCacheCall)
    def postCacheCall(*args):
        """postCacheCall(SoState state, GLState poststate)"""
        return _coin.SoGLLazyElement_postCacheCall(*args)

    postCacheCall = staticmethod(postCacheCall)
    def mergeCacheInfo(*args):
        """mergeCacheInfo(SoState state, GLState childprestate, GLState childpoststate)"""
        return _coin.SoGLLazyElement_mergeCacheInfo(*args)

    mergeCacheInfo = staticmethod(mergeCacheInfo)
    def updateColorVBO(self, *args):
        """updateColorVBO(self, SoVBO vbo)"""
        return _coin.SoGLLazyElement_updateColorVBO(self, *args)

SoGLLazyElement_swigregister = _coin.SoGLLazyElement_swigregister
SoGLLazyElement_swigregister(SoGLLazyElement)

def SoGLLazyElement_getClassTypeId():
  """SoGLLazyElement_getClassTypeId() -> SoType"""
  return _coin.SoGLLazyElement_getClassTypeId()

def SoGLLazyElement_getClassStackIndex():
  """SoGLLazyElement_getClassStackIndex() -> int"""
  return _coin.SoGLLazyElement_getClassStackIndex()

def SoGLLazyElement_createInstance():
  """SoGLLazyElement_createInstance() -> void"""
  return _coin.SoGLLazyElement_createInstance()

def SoGLLazyElement_initClass():
  """SoGLLazyElement_initClass()"""
  return _coin.SoGLLazyElement_initClass()

def SoGLLazyElement_sendAllMaterial(*args):
  """SoGLLazyElement_sendAllMaterial(SoState state)"""
  return _coin.SoGLLazyElement_sendAllMaterial(*args)

def SoGLLazyElement_sendNoMaterial(*args):
  """SoGLLazyElement_sendNoMaterial(SoState state)"""
  return _coin.SoGLLazyElement_sendNoMaterial(*args)

def SoGLLazyElement_sendOnlyDiffuseColor(*args):
  """SoGLLazyElement_sendOnlyDiffuseColor(SoState state)"""
  return _coin.SoGLLazyElement_sendOnlyDiffuseColor(*args)

def SoGLLazyElement_sendLightModel(*args):
  """SoGLLazyElement_sendLightModel(SoState state, int32_t model)"""
  return _coin.SoGLLazyElement_sendLightModel(*args)

def SoGLLazyElement_sendPackedDiffuse(*args):
  """SoGLLazyElement_sendPackedDiffuse(SoState state, uint32_t diffuse)"""
  return _coin.SoGLLazyElement_sendPackedDiffuse(*args)

def SoGLLazyElement_sendFlatshading(*args):
  """SoGLLazyElement_sendFlatshading(SoState state, SbBool onoff)"""
  return _coin.SoGLLazyElement_sendFlatshading(*args)

def SoGLLazyElement_sendVertexOrdering(*args):
  """SoGLLazyElement_sendVertexOrdering(SoState state, VertexOrdering ordering)"""
  return _coin.SoGLLazyElement_sendVertexOrdering(*args)

def SoGLLazyElement_sendTwosideLighting(*args):
  """SoGLLazyElement_sendTwosideLighting(SoState state, SbBool onoff)"""
  return _coin.SoGLLazyElement_sendTwosideLighting(*args)

def SoGLLazyElement_sendBackfaceCulling(*args):
  """SoGLLazyElement_sendBackfaceCulling(SoState state, SbBool onoff)"""
  return _coin.SoGLLazyElement_sendBackfaceCulling(*args)

def SoGLLazyElement_isColorIndex(*args):
  """SoGLLazyElement_isColorIndex(SoState state) -> SbBool"""
  return _coin.SoGLLazyElement_isColorIndex(*args)

def SoGLLazyElement_getInstance(*args):
  """SoGLLazyElement_getInstance(SoState state) -> SoGLLazyElement"""
  return _coin.SoGLLazyElement_getInstance(*args)

def SoGLLazyElement_beginCaching(*args):
  """SoGLLazyElement_beginCaching(SoState state, GLState prestate, GLState poststate)"""
  return _coin.SoGLLazyElement_beginCaching(*args)

def SoGLLazyElement_endCaching(*args):
  """SoGLLazyElement_endCaching(SoState state)"""
  return _coin.SoGLLazyElement_endCaching(*args)

def SoGLLazyElement_preCacheCall(*args):
  """SoGLLazyElement_preCacheCall(SoState state, GLState prestate) -> SbBool"""
  return _coin.SoGLLazyElement_preCacheCall(*args)

def SoGLLazyElement_postCacheCall(*args):
  """SoGLLazyElement_postCacheCall(SoState state, GLState poststate)"""
  return _coin.SoGLLazyElement_postCacheCall(*args)

def SoGLLazyElement_mergeCacheInfo(*args):
  """SoGLLazyElement_mergeCacheInfo(SoState state, GLState childprestate, GLState childpoststate)"""
  return _coin.SoGLLazyElement_mergeCacheInfo(*args)

class SoGLRenderCache(SoCache):
    """Proxy of C++ SoGLRenderCache class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _coin.delete_SoGLRenderCache
    __del__ = lambda self : None;
    def isValid(self, *args):
        """isValid(self, SoState state) -> SbBool"""
        return _coin.SoGLRenderCache_isValid(self, *args)

    def addNestedCache(self, *args):
        """addNestedCache(self, SoGLDisplayList child)"""
        return _coin.SoGLRenderCache_addNestedCache(self, *args)

SoGLRenderCache_swigregister = _coin.SoGLRenderCache_swigregister
SoGLRenderCache_swigregister(SoGLRenderCache)

class SoNormalCache(SoCache):
    """Proxy of C++ SoNormalCache class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, SoState state) -> SoNormalCache"""
        this = _coin.new_SoNormalCache(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoNormalCache
    __del__ = lambda self : None;
    def set(self, *args):
        """
        set(self, int num, SbVec3f normals)
        set(self, SoNormalGenerator generator)
        """
        return _coin.SoNormalCache_set(self, *args)

    def getNum(self):
        """getNum(self) -> int"""
        return _coin.SoNormalCache_getNum(self)

    def getNormals(self):
        """getNormals(self) -> SbVec3f"""
        return _coin.SoNormalCache_getNormals(self)

    def getNumIndices(self):
        """getNumIndices(self) -> int"""
        return _coin.SoNormalCache_getNumIndices(self)

    def getIndices(self):
        """getIndices(self) -> int32_t"""
        return _coin.SoNormalCache_getIndices(self)

    def generatePerVertex(self, *args):
        """
        generatePerVertex(self, SbVec3f coords, unsigned int numcoords, int32_t coordindices, 
            int numcoordindices, float crease_angle, 
            SbVec3f facenormals = None, int numfacenormals = -1, 
            SbBool ccw = 1, SbBool tristrip = 0)
        generatePerVertex(self, SbVec3f coords, unsigned int numcoords, int32_t coordindices, 
            int numcoordindices, float crease_angle, 
            SbVec3f facenormals = None, int numfacenormals = -1, 
            SbBool ccw = 1)
        generatePerVertex(self, SbVec3f coords, unsigned int numcoords, int32_t coordindices, 
            int numcoordindices, float crease_angle, 
            SbVec3f facenormals = None, int numfacenormals = -1)
        generatePerVertex(self, SbVec3f coords, unsigned int numcoords, int32_t coordindices, 
            int numcoordindices, float crease_angle, 
            SbVec3f facenormals = None)
        generatePerVertex(self, SbVec3f coords, unsigned int numcoords, int32_t coordindices, 
            int numcoordindices, float crease_angle)
        """
        return _coin.SoNormalCache_generatePerVertex(self, *args)

    def generatePerFace(self, *args):
        """
        generatePerFace(self, SbVec3f coords, unsigned int numcoords, int32_t coordindices, 
            int numcoorindices, SbBool ccw)
        """
        return _coin.SoNormalCache_generatePerFace(self, *args)

    def generatePerFaceStrip(self, *args):
        """
        generatePerFaceStrip(self, SbVec3f coords, unsigned int numcoords, int32_t coordindices, 
            int numcoorindices, SbBool ccw)
        """
        return _coin.SoNormalCache_generatePerFaceStrip(self, *args)

    def generatePerStrip(self, *args):
        """
        generatePerStrip(self, SbVec3f coords, unsigned int numcoords, int32_t coordindices, 
            int numcoorindices, SbBool ccw)
        """
        return _coin.SoNormalCache_generatePerStrip(self, *args)

    def generatePerVertexQuad(self, *args):
        """
        generatePerVertexQuad(self, SbVec3f coords, unsigned int numcoords, int vPerRow, 
            int vPerColumn, SbBool ccw)
        """
        return _coin.SoNormalCache_generatePerVertexQuad(self, *args)

    def generatePerFaceQuad(self, *args):
        """
        generatePerFaceQuad(self, SbVec3f coords, unsigned int numcoords, int vPerRow, 
            int vPerColumn, SbBool ccw)
        """
        return _coin.SoNormalCache_generatePerFaceQuad(self, *args)

    def generatePerRowQuad(self, *args):
        """
        generatePerRowQuad(self, SbVec3f coords, unsigned int numcoords, int vPerRow, 
            int vPerColumn, SbBool ccw)
        """
        return _coin.SoNormalCache_generatePerRowQuad(self, *args)

SoNormalCache_swigregister = _coin.SoNormalCache_swigregister
SoNormalCache_swigregister(SoNormalCache)

class SoTextureCoordinateCache(SoCache):
    """Proxy of C++ SoTextureCoordinateCache class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, SoState state) -> SoTextureCoordinateCache"""
        this = _coin.new_SoTextureCoordinateCache(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoTextureCoordinateCache
    __del__ = lambda self : None;
    def generate(self, *args):
        """generate(self, SbBox3f bbox, SbVec3f vertices, int numvertices)"""
        return _coin.SoTextureCoordinateCache_generate(self, *args)

    def get(self):
        """get(self) -> SbVec2f"""
        return _coin.SoTextureCoordinateCache_get(self)

    def getNum(self):
        """getNum(self) -> int"""
        return _coin.SoTextureCoordinateCache_getNum(self)

SoTextureCoordinateCache_swigregister = _coin.SoTextureCoordinateCache_swigregister
SoTextureCoordinateCache_swigregister(SoTextureCoordinateCache)

class SoDetail(object):
    """Proxy of C++ SoDetail class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _coin.delete_SoDetail
    __del__ = lambda self : None;
    def initClass():
        """initClass()"""
        return _coin.SoDetail_initClass()

    initClass = staticmethod(initClass)
    def initClasses():
        """initClasses()"""
        return _coin.SoDetail_initClasses()

    initClasses = staticmethod(initClasses)
    def copy(self):
        """copy(self) -> SoDetail"""
        return _coin.SoDetail_copy(self)

    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoDetail_getTypeId(self)

    def isOfType(self, *args):
        """isOfType(self, SoType type) -> SbBool"""
        return _coin.SoDetail_isOfType(self, *args)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoDetail_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
SoDetail_swigregister = _coin.SoDetail_swigregister
SoDetail_swigregister(SoDetail)

def SoDetail_initClass():
  """SoDetail_initClass()"""
  return _coin.SoDetail_initClass()

def SoDetail_initClasses():
  """SoDetail_initClasses()"""
  return _coin.SoDetail_initClasses()

def SoDetail_getClassTypeId():
  """SoDetail_getClassTypeId() -> SoType"""
  return _coin.SoDetail_getClassTypeId()

class SoConeDetail(SoDetail):
    """Proxy of C++ SoConeDetail class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoConeDetail_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoConeDetail_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def cleanupClass():
        """cleanupClass()"""
        return _coin.SoConeDetail_cleanupClass()

    cleanupClass = staticmethod(cleanupClass)
    def __init__(self): 
        """__init__(self) -> SoConeDetail"""
        this = _coin.new_SoConeDetail()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoConeDetail
    __del__ = lambda self : None;
    def initClass():
        """initClass()"""
        return _coin.SoConeDetail_initClass()

    initClass = staticmethod(initClass)
    def copy(self):
        """copy(self) -> SoDetail"""
        return _coin.SoConeDetail_copy(self)

    def setPart(self, *args):
        """setPart(self, int part)"""
        return _coin.SoConeDetail_setPart(self, *args)

    def getPart(self):
        """getPart(self) -> int"""
        return _coin.SoConeDetail_getPart(self)

SoConeDetail_swigregister = _coin.SoConeDetail_swigregister
SoConeDetail_swigregister(SoConeDetail)

def SoConeDetail_getClassTypeId():
  """SoConeDetail_getClassTypeId() -> SoType"""
  return _coin.SoConeDetail_getClassTypeId()

def SoConeDetail_cleanupClass():
  """SoConeDetail_cleanupClass()"""
  return _coin.SoConeDetail_cleanupClass()

def SoConeDetail_initClass():
  """SoConeDetail_initClass()"""
  return _coin.SoConeDetail_initClass()

class SoCubeDetail(SoDetail):
    """Proxy of C++ SoCubeDetail class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoCubeDetail_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoCubeDetail_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def cleanupClass():
        """cleanupClass()"""
        return _coin.SoCubeDetail_cleanupClass()

    cleanupClass = staticmethod(cleanupClass)
    def __init__(self): 
        """__init__(self) -> SoCubeDetail"""
        this = _coin.new_SoCubeDetail()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoCubeDetail
    __del__ = lambda self : None;
    def initClass():
        """initClass()"""
        return _coin.SoCubeDetail_initClass()

    initClass = staticmethod(initClass)
    def copy(self):
        """copy(self) -> SoDetail"""
        return _coin.SoCubeDetail_copy(self)

    def setPart(self, *args):
        """setPart(self, int part)"""
        return _coin.SoCubeDetail_setPart(self, *args)

    def getPart(self):
        """getPart(self) -> int"""
        return _coin.SoCubeDetail_getPart(self)

SoCubeDetail_swigregister = _coin.SoCubeDetail_swigregister
SoCubeDetail_swigregister(SoCubeDetail)

def SoCubeDetail_getClassTypeId():
  """SoCubeDetail_getClassTypeId() -> SoType"""
  return _coin.SoCubeDetail_getClassTypeId()

def SoCubeDetail_cleanupClass():
  """SoCubeDetail_cleanupClass()"""
  return _coin.SoCubeDetail_cleanupClass()

def SoCubeDetail_initClass():
  """SoCubeDetail_initClass()"""
  return _coin.SoCubeDetail_initClass()

class SoCylinderDetail(SoDetail):
    """Proxy of C++ SoCylinderDetail class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoCylinderDetail_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoCylinderDetail_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def cleanupClass():
        """cleanupClass()"""
        return _coin.SoCylinderDetail_cleanupClass()

    cleanupClass = staticmethod(cleanupClass)
    def __init__(self): 
        """__init__(self) -> SoCylinderDetail"""
        this = _coin.new_SoCylinderDetail()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoCylinderDetail
    __del__ = lambda self : None;
    def initClass():
        """initClass()"""
        return _coin.SoCylinderDetail_initClass()

    initClass = staticmethod(initClass)
    def copy(self):
        """copy(self) -> SoDetail"""
        return _coin.SoCylinderDetail_copy(self)

    def setPart(self, *args):
        """setPart(self, int part)"""
        return _coin.SoCylinderDetail_setPart(self, *args)

    def getPart(self):
        """getPart(self) -> int"""
        return _coin.SoCylinderDetail_getPart(self)

SoCylinderDetail_swigregister = _coin.SoCylinderDetail_swigregister
SoCylinderDetail_swigregister(SoCylinderDetail)

def SoCylinderDetail_getClassTypeId():
  """SoCylinderDetail_getClassTypeId() -> SoType"""
  return _coin.SoCylinderDetail_getClassTypeId()

def SoCylinderDetail_cleanupClass():
  """SoCylinderDetail_cleanupClass()"""
  return _coin.SoCylinderDetail_cleanupClass()

def SoCylinderDetail_initClass():
  """SoCylinderDetail_initClass()"""
  return _coin.SoCylinderDetail_initClass()

class SoPointDetail(SoDetail):
    """Proxy of C++ SoPointDetail class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoPointDetail_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoPointDetail_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def cleanupClass():
        """cleanupClass()"""
        return _coin.SoPointDetail_cleanupClass()

    cleanupClass = staticmethod(cleanupClass)
    def __init__(self): 
        """__init__(self) -> SoPointDetail"""
        this = _coin.new_SoPointDetail()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoPointDetail
    __del__ = lambda self : None;
    def initClass():
        """initClass()"""
        return _coin.SoPointDetail_initClass()

    initClass = staticmethod(initClass)
    def copy(self):
        """copy(self) -> SoDetail"""
        return _coin.SoPointDetail_copy(self)

    def getCoordinateIndex(self):
        """getCoordinateIndex(self) -> int"""
        return _coin.SoPointDetail_getCoordinateIndex(self)

    def getMaterialIndex(self):
        """getMaterialIndex(self) -> int"""
        return _coin.SoPointDetail_getMaterialIndex(self)

    def getNormalIndex(self):
        """getNormalIndex(self) -> int"""
        return _coin.SoPointDetail_getNormalIndex(self)

    def getTextureCoordIndex(self):
        """getTextureCoordIndex(self) -> int"""
        return _coin.SoPointDetail_getTextureCoordIndex(self)

    def setCoordinateIndex(self, *args):
        """setCoordinateIndex(self, int idx)"""
        return _coin.SoPointDetail_setCoordinateIndex(self, *args)

    def setMaterialIndex(self, *args):
        """setMaterialIndex(self, int idx)"""
        return _coin.SoPointDetail_setMaterialIndex(self, *args)

    def setNormalIndex(self, *args):
        """setNormalIndex(self, int idx)"""
        return _coin.SoPointDetail_setNormalIndex(self, *args)

    def setTextureCoordIndex(self, *args):
        """setTextureCoordIndex(self, int idx)"""
        return _coin.SoPointDetail_setTextureCoordIndex(self, *args)

SoPointDetail_swigregister = _coin.SoPointDetail_swigregister
SoPointDetail_swigregister(SoPointDetail)

def SoPointDetail_getClassTypeId():
  """SoPointDetail_getClassTypeId() -> SoType"""
  return _coin.SoPointDetail_getClassTypeId()

def SoPointDetail_cleanupClass():
  """SoPointDetail_cleanupClass()"""
  return _coin.SoPointDetail_cleanupClass()

def SoPointDetail_initClass():
  """SoPointDetail_initClass()"""
  return _coin.SoPointDetail_initClass()

class SoFaceDetail(SoDetail):
    """Proxy of C++ SoFaceDetail class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoFaceDetail_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoFaceDetail_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def cleanupClass():
        """cleanupClass()"""
        return _coin.SoFaceDetail_cleanupClass()

    cleanupClass = staticmethod(cleanupClass)
    def __init__(self): 
        """__init__(self) -> SoFaceDetail"""
        this = _coin.new_SoFaceDetail()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoFaceDetail
    __del__ = lambda self : None;
    def initClass():
        """initClass()"""
        return _coin.SoFaceDetail_initClass()

    initClass = staticmethod(initClass)
    def copy(self):
        """copy(self) -> SoDetail"""
        return _coin.SoFaceDetail_copy(self)

    def getNumPoints(self):
        """getNumPoints(self) -> int"""
        return _coin.SoFaceDetail_getNumPoints(self)

    def getPoint(self, *args):
        """getPoint(self, int idx) -> SoPointDetail"""
        return _coin.SoFaceDetail_getPoint(self, *args)

    def getPoints(self):
        """getPoints(self) -> SoPointDetail"""
        return _coin.SoFaceDetail_getPoints(self)

    def getFaceIndex(self):
        """getFaceIndex(self) -> int"""
        return _coin.SoFaceDetail_getFaceIndex(self)

    def getPartIndex(self):
        """getPartIndex(self) -> int"""
        return _coin.SoFaceDetail_getPartIndex(self)

    def setNumPoints(self, *args):
        """setNumPoints(self, int num)"""
        return _coin.SoFaceDetail_setNumPoints(self, *args)

    def setPoint(self, *args):
        """setPoint(self, int idx, SoPointDetail detail)"""
        return _coin.SoFaceDetail_setPoint(self, *args)

    def setFaceIndex(self, *args):
        """setFaceIndex(self, int idx)"""
        return _coin.SoFaceDetail_setFaceIndex(self, *args)

    def setPartIndex(self, *args):
        """setPartIndex(self, int idx)"""
        return _coin.SoFaceDetail_setPartIndex(self, *args)

    def incFaceIndex(self):
        """incFaceIndex(self)"""
        return _coin.SoFaceDetail_incFaceIndex(self)

    def incPartIndex(self):
        """incPartIndex(self)"""
        return _coin.SoFaceDetail_incPartIndex(self)

SoFaceDetail_swigregister = _coin.SoFaceDetail_swigregister
SoFaceDetail_swigregister(SoFaceDetail)

def SoFaceDetail_getClassTypeId():
  """SoFaceDetail_getClassTypeId() -> SoType"""
  return _coin.SoFaceDetail_getClassTypeId()

def SoFaceDetail_cleanupClass():
  """SoFaceDetail_cleanupClass()"""
  return _coin.SoFaceDetail_cleanupClass()

def SoFaceDetail_initClass():
  """SoFaceDetail_initClass()"""
  return _coin.SoFaceDetail_initClass()

class SoLineDetail(SoDetail):
    """Proxy of C++ SoLineDetail class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoLineDetail_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoLineDetail_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def cleanupClass():
        """cleanupClass()"""
        return _coin.SoLineDetail_cleanupClass()

    cleanupClass = staticmethod(cleanupClass)
    def __init__(self): 
        """__init__(self) -> SoLineDetail"""
        this = _coin.new_SoLineDetail()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoLineDetail
    __del__ = lambda self : None;
    def initClass():
        """initClass()"""
        return _coin.SoLineDetail_initClass()

    initClass = staticmethod(initClass)
    def copy(self):
        """copy(self) -> SoDetail"""
        return _coin.SoLineDetail_copy(self)

    def getPoint0(self):
        """getPoint0(self) -> SoPointDetail"""
        return _coin.SoLineDetail_getPoint0(self)

    def getPoint1(self):
        """getPoint1(self) -> SoPointDetail"""
        return _coin.SoLineDetail_getPoint1(self)

    def getLineIndex(self):
        """getLineIndex(self) -> int"""
        return _coin.SoLineDetail_getLineIndex(self)

    def getPartIndex(self):
        """getPartIndex(self) -> int"""
        return _coin.SoLineDetail_getPartIndex(self)

    def setPoint0(self, *args):
        """setPoint0(self, SoPointDetail detail)"""
        return _coin.SoLineDetail_setPoint0(self, *args)

    def setPoint1(self, *args):
        """setPoint1(self, SoPointDetail detail)"""
        return _coin.SoLineDetail_setPoint1(self, *args)

    def setLineIndex(self, *args):
        """setLineIndex(self, int idx)"""
        return _coin.SoLineDetail_setLineIndex(self, *args)

    def setPartIndex(self, *args):
        """setPartIndex(self, int idx)"""
        return _coin.SoLineDetail_setPartIndex(self, *args)

    def incLineIndex(self):
        """incLineIndex(self)"""
        return _coin.SoLineDetail_incLineIndex(self)

    def incPartIndex(self):
        """incPartIndex(self)"""
        return _coin.SoLineDetail_incPartIndex(self)

SoLineDetail_swigregister = _coin.SoLineDetail_swigregister
SoLineDetail_swigregister(SoLineDetail)

def SoLineDetail_getClassTypeId():
  """SoLineDetail_getClassTypeId() -> SoType"""
  return _coin.SoLineDetail_getClassTypeId()

def SoLineDetail_cleanupClass():
  """SoLineDetail_cleanupClass()"""
  return _coin.SoLineDetail_cleanupClass()

def SoLineDetail_initClass():
  """SoLineDetail_initClass()"""
  return _coin.SoLineDetail_initClass()

class SoNodeKitDetail(SoDetail):
    """Proxy of C++ SoNodeKitDetail class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoNodeKitDetail_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoNodeKitDetail_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def cleanupClass():
        """cleanupClass()"""
        return _coin.SoNodeKitDetail_cleanupClass()

    cleanupClass = staticmethod(cleanupClass)
    def __init__(self): 
        """__init__(self) -> SoNodeKitDetail"""
        this = _coin.new_SoNodeKitDetail()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoNodeKitDetail
    __del__ = lambda self : None;
    def initClass():
        """initClass()"""
        return _coin.SoNodeKitDetail_initClass()

    initClass = staticmethod(initClass)
    def copy(self):
        """copy(self) -> SoDetail"""
        return _coin.SoNodeKitDetail_copy(self)

    def setNodeKit(self, *args):
        """setNodeKit(self, SoBaseKit kit)"""
        return _coin.SoNodeKitDetail_setNodeKit(self, *args)

    def getNodeKit(self):
        """getNodeKit(self) -> SoBaseKit"""
        return _coin.SoNodeKitDetail_getNodeKit(self)

    def setPart(self, *args):
        """setPart(self, SoNode part)"""
        return _coin.SoNodeKitDetail_setPart(self, *args)

    def getPart(self):
        """getPart(self) -> SoNode"""
        return _coin.SoNodeKitDetail_getPart(self)

    def setPartName(self, *args):
        """setPartName(self, SbName name)"""
        return _coin.SoNodeKitDetail_setPartName(self, *args)

    def getPartName(self):
        """getPartName(self) -> SbName"""
        return _coin.SoNodeKitDetail_getPartName(self)

SoNodeKitDetail_swigregister = _coin.SoNodeKitDetail_swigregister
SoNodeKitDetail_swigregister(SoNodeKitDetail)

def SoNodeKitDetail_getClassTypeId():
  """SoNodeKitDetail_getClassTypeId() -> SoType"""
  return _coin.SoNodeKitDetail_getClassTypeId()

def SoNodeKitDetail_cleanupClass():
  """SoNodeKitDetail_cleanupClass()"""
  return _coin.SoNodeKitDetail_cleanupClass()

def SoNodeKitDetail_initClass():
  """SoNodeKitDetail_initClass()"""
  return _coin.SoNodeKitDetail_initClass()

class SoTextDetail(SoDetail):
    """Proxy of C++ SoTextDetail class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTextDetail_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextDetail_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def cleanupClass():
        """cleanupClass()"""
        return _coin.SoTextDetail_cleanupClass()

    cleanupClass = staticmethod(cleanupClass)
    def __init__(self): 
        """__init__(self) -> SoTextDetail"""
        this = _coin.new_SoTextDetail()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoTextDetail
    __del__ = lambda self : None;
    def initClass():
        """initClass()"""
        return _coin.SoTextDetail_initClass()

    initClass = staticmethod(initClass)
    def copy(self):
        """copy(self) -> SoDetail"""
        return _coin.SoTextDetail_copy(self)

    def getStringIndex(self):
        """getStringIndex(self) -> int"""
        return _coin.SoTextDetail_getStringIndex(self)

    def getCharacterIndex(self):
        """getCharacterIndex(self) -> int"""
        return _coin.SoTextDetail_getCharacterIndex(self)

    def getPart(self):
        """getPart(self) -> int"""
        return _coin.SoTextDetail_getPart(self)

    def setStringIndex(self, *args):
        """setStringIndex(self, int idx)"""
        return _coin.SoTextDetail_setStringIndex(self, *args)

    def setCharacterIndex(self, *args):
        """setCharacterIndex(self, int idx)"""
        return _coin.SoTextDetail_setCharacterIndex(self, *args)

    def setPart(self, *args):
        """setPart(self, int idx)"""
        return _coin.SoTextDetail_setPart(self, *args)

SoTextDetail_swigregister = _coin.SoTextDetail_swigregister
SoTextDetail_swigregister(SoTextDetail)

def SoTextDetail_getClassTypeId():
  """SoTextDetail_getClassTypeId() -> SoType"""
  return _coin.SoTextDetail_getClassTypeId()

def SoTextDetail_cleanupClass():
  """SoTextDetail_cleanupClass()"""
  return _coin.SoTextDetail_cleanupClass()

def SoTextDetail_initClass():
  """SoTextDetail_initClass()"""
  return _coin.SoTextDetail_initClass()

class SoSFNode(SoSField):
    """Proxy of C++ SoSFNode class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFNode"""
        this = _coin.new_SoSFNode()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFNode
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFNode_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFNode_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFNode_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFNode_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFNode_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SoNode"""
        return _coin.SoSFNode_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFNode field) -> int"""
        return _coin.SoSFNode___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFNode field) -> int"""
        return _coin.SoSFNode___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFNode_initClass()

    initClass = staticmethod(initClass)
    def fixCopy(self, *args):
        """fixCopy(self, SbBool copyconnections)"""
        return _coin.SoSFNode_fixCopy(self, *args)

    def referencesCopy(self):
        """referencesCopy(self) -> SbBool"""
        return _coin.SoSFNode_referencesCopy(self)

    def setValue(self, *args):
        """
        setValue(self, SoNode newvalue)
        setValue(self, SoSFNode other)
        """
        return _coin.SoSFNode_setValue(self, *args)

SoSFNode_swigregister = _coin.SoSFNode_swigregister
SoSFNode_swigregister(SoSFNode)

def SoSFNode_createInstance():
  """SoSFNode_createInstance() -> void"""
  return _coin.SoSFNode_createInstance()

def SoSFNode_getClassTypeId():
  """SoSFNode_getClassTypeId() -> SoType"""
  return _coin.SoSFNode_getClassTypeId()

def SoSFNode_initClass():
  """SoSFNode_initClass()"""
  return _coin.SoSFNode_initClass()

SO_CATALOG_NAME_NOT_FOUND = _coin.SO_CATALOG_NAME_NOT_FOUND
class SoNodekitCatalog(object):
    """Proxy of C++ SoNodekitCatalog class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def initClass():
        """initClass()"""
        return _coin.SoNodekitCatalog_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoNodekitCatalog"""
        this = _coin.new_SoNodekitCatalog()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoNodekitCatalog
    __del__ = lambda self : None;
    def getNumEntries(self):
        """getNumEntries(self) -> int"""
        return _coin.SoNodekitCatalog_getNumEntries(self)

    def getPartNumber(self, *args):
        """getPartNumber(self, SbName name) -> int"""
        return _coin.SoNodekitCatalog_getPartNumber(self, *args)

    def getName(self, *args):
        """getName(self, int part) -> SbName"""
        return _coin.SoNodekitCatalog_getName(self, *args)

    def getType(self, *args):
        """
        getType(self, int part) -> SoType
        getType(self, SbName name) -> SoType
        """
        return _coin.SoNodekitCatalog_getType(self, *args)

    def getDefaultType(self, *args):
        """
        getDefaultType(self, int part) -> SoType
        getDefaultType(self, SbName name) -> SoType
        """
        return _coin.SoNodekitCatalog_getDefaultType(self, *args)

    def isNullByDefault(self, *args):
        """
        isNullByDefault(self, int part) -> SbBool
        isNullByDefault(self, SbName name) -> SbBool
        """
        return _coin.SoNodekitCatalog_isNullByDefault(self, *args)

    def isLeaf(self, *args):
        """
        isLeaf(self, int part) -> SbBool
        isLeaf(self, SbName name) -> SbBool
        """
        return _coin.SoNodekitCatalog_isLeaf(self, *args)

    def getParentName(self, *args):
        """
        getParentName(self, int part) -> SbName
        getParentName(self, SbName name) -> SbName
        """
        return _coin.SoNodekitCatalog_getParentName(self, *args)

    def getParentPartNumber(self, *args):
        """
        getParentPartNumber(self, int part) -> int
        getParentPartNumber(self, SbName name) -> int
        """
        return _coin.SoNodekitCatalog_getParentPartNumber(self, *args)

    def getRightSiblingName(self, *args):
        """
        getRightSiblingName(self, int part) -> SbName
        getRightSiblingName(self, SbName name) -> SbName
        """
        return _coin.SoNodekitCatalog_getRightSiblingName(self, *args)

    def getRightSiblingPartNumber(self, *args):
        """
        getRightSiblingPartNumber(self, int part) -> int
        getRightSiblingPartNumber(self, SbName name) -> int
        """
        return _coin.SoNodekitCatalog_getRightSiblingPartNumber(self, *args)

    def isList(self, *args):
        """
        isList(self, int part) -> SbBool
        isList(self, SbName name) -> SbBool
        """
        return _coin.SoNodekitCatalog_isList(self, *args)

    def getListContainerType(self, *args):
        """
        getListContainerType(self, int part) -> SoType
        getListContainerType(self, SbName name) -> SoType
        """
        return _coin.SoNodekitCatalog_getListContainerType(self, *args)

    def getListItemTypes(self, *args):
        """
        getListItemTypes(self, int part) -> SoTypeList
        getListItemTypes(self, SbName name) -> SoTypeList
        """
        return _coin.SoNodekitCatalog_getListItemTypes(self, *args)

    def isPublic(self, *args):
        """
        isPublic(self, int part) -> SbBool
        isPublic(self, SbName name) -> SbBool
        """
        return _coin.SoNodekitCatalog_isPublic(self, *args)

    def clone(self, *args):
        """clone(self, SoType type) -> SoNodekitCatalog"""
        return _coin.SoNodekitCatalog_clone(self, *args)

    def addEntry(self, *args):
        """
        addEntry(self, SbName name, SoType type, SoType defaulttype, SbBool isdefaultnull, 
            SbName parent, SbName rightsibling, 
            SbBool islist, SoType listcontainertype, 
            SoType listitemtype, SbBool ispublic) -> SbBool
        """
        return _coin.SoNodekitCatalog_addEntry(self, *args)

    def addListItemType(self, *args):
        """
        addListItemType(self, int part, SoType type)
        addListItemType(self, SbName name, SoType type)
        """
        return _coin.SoNodekitCatalog_addListItemType(self, *args)

    def narrowTypes(self, *args):
        """narrowTypes(self, SbName name, SoType newtype, SoType newdefaulttype)"""
        return _coin.SoNodekitCatalog_narrowTypes(self, *args)

    def setNullByDefault(self, *args):
        """setNullByDefault(self, SbName name, SbBool nullbydefault)"""
        return _coin.SoNodekitCatalog_setNullByDefault(self, *args)

    def recursiveSearch(self, *args):
        """recursiveSearch(self, int part, SbName name, SoTypeList checked) -> SbBool"""
        return _coin.SoNodekitCatalog_recursiveSearch(self, *args)

    def printCheck(self):
        """printCheck(self)"""
        return _coin.SoNodekitCatalog_printCheck(self)

SoNodekitCatalog_swigregister = _coin.SoNodekitCatalog_swigregister
SoNodekitCatalog_swigregister(SoNodekitCatalog)

def SoNodekitCatalog_initClass():
  """SoNodekitCatalog_initClass()"""
  return _coin.SoNodekitCatalog_initClass()

class SoSFName(SoSField):
    """Proxy of C++ SoSFName class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFName"""
        this = _coin.new_SoSFName()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFName
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFName_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFName_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFName_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFName_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFName_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SbName"""
        return _coin.SoSFName_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFName field) -> int"""
        return _coin.SoSFName___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFName field) -> int"""
        return _coin.SoSFName___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFName_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbName newvalue)
        setValue(self, char name)
        setValue(self, SoSFName other)
        """
        return _coin.SoSFName_setValue(self, *args)

SoSFName_swigregister = _coin.SoSFName_swigregister
SoSFName_swigregister(SoSFName)

def SoSFName_createInstance():
  """SoSFName_createInstance() -> void"""
  return _coin.SoSFName_createInstance()

def SoSFName_getClassTypeId():
  """SoSFName_getClassTypeId() -> SoType"""
  return _coin.SoSFName_getClassTypeId()

def SoSFName_initClass():
  """SoSFName_initClass()"""
  return _coin.SoSFName_initClass()

class SoMFName(SoMField):
    """Proxy of C++ SoMFName class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFName"""
        this = _coin.new_SoMFName()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFName
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFName_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFName_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFName_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFName_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFName_isSame(self, *args)

    def find(self, *args):
        """
        find(self, SbName value, SbBool addifnotfound = 0) -> int
        find(self, SbName value) -> int
        """
        return _coin.SoMFName_find(self, *args)

    def set1Value(self, *args):
        """set1Value(self, int idx, SbName value)"""
        return _coin.SoMFName_set1Value(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFName field) -> SbBool"""
        return _coin.SoMFName___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFName field) -> SbBool"""
        return _coin.SoMFName___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SbName"""
        return _coin.SoMFName_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFName_finishEditing(self)

    def initClass():
        """initClass()"""
        return _coin.SoMFName_initClass()

    initClass = staticmethod(initClass)
    def setValues(*args):
       if len(args) == 2:
         return _coin.SoMFName_setValues(args[0], 0, len(args[1]), args[1])
       elif len(args) == 3:
         return _coin.SoMFName_setValues(args[0], args[1], len(args[2]), args[2])
       return apply(_coin.SoMFName_setValues,args)


    def __getitem__(self, *args):
        """__getitem__(self, int i) -> SbName"""
        return _coin.SoMFName___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, SbName value)"""
        return _coin.SoMFName___setitem__(self, *args)

    def setValue(self, *args):
        """
        setValue(self, SbName value)
        setValue(self, char str)
        setValue(self, SoMFName other)
        """
        return _coin.SoMFName_setValue(self, *args)

    def getValues(self, i = 0):
        """
        getValues(self, int i = 0) -> SbName
        getValues(self) -> SbName
        """
        return _coin.SoMFName_getValues(self, i)

SoMFName_swigregister = _coin.SoMFName_swigregister
SoMFName_swigregister(SoMFName)

def SoMFName_createInstance():
  """SoMFName_createInstance() -> void"""
  return _coin.SoMFName_createInstance()

def SoMFName_getClassTypeId():
  """SoMFName_getClassTypeId() -> SoType"""
  return _coin.SoMFName_getClassTypeId()

def SoMFName_initClass():
  """SoMFName_initClass()"""
  return _coin.SoMFName_initClass()

class SoNodeKitListPart(SoNode):
    """Proxy of C++ SoNodeKitListPart class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoNodeKitListPart_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoNodeKitListPart_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoNodeKitListPart_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoNodeKitListPart"""
        this = _coin.new_SoNodeKitListPart()
        try: self.this.append(this)
        except: self.this = this
    def getContainerType(self):
        """getContainerType(self) -> SoType"""
        return _coin.SoNodeKitListPart_getContainerType(self)

    def setContainerType(self, *args):
        """setContainerType(self, SoType newContainerType)"""
        return _coin.SoNodeKitListPart_setContainerType(self, *args)

    def getChildTypes(self):
        """getChildTypes(self) -> SoTypeList"""
        return _coin.SoNodeKitListPart_getChildTypes(self)

    def addChildType(self, *args):
        """addChildType(self, SoType typeToAdd)"""
        return _coin.SoNodeKitListPart_addChildType(self, *args)

    def isTypePermitted(self, *args):
        """isTypePermitted(self, SoType typeToCheck) -> SbBool"""
        return _coin.SoNodeKitListPart_isTypePermitted(self, *args)

    def isChildPermitted(self, *args):
        """isChildPermitted(self, SoNode child) -> SbBool"""
        return _coin.SoNodeKitListPart_isChildPermitted(self, *args)

    def containerSet(self, *args):
        """containerSet(self, char fieldDataString)"""
        return _coin.SoNodeKitListPart_containerSet(self, *args)

    def lockTypes(self):
        """lockTypes(self)"""
        return _coin.SoNodeKitListPart_lockTypes(self)

    def isTypeLocked(self):
        """isTypeLocked(self) -> SbBool"""
        return _coin.SoNodeKitListPart_isTypeLocked(self)

    def addChild(self, *args):
        """addChild(self, SoNode child)"""
        return _coin.SoNodeKitListPart_addChild(self, *args)

    def insertChild(self, *args):
        """insertChild(self, SoNode child, int childIndex)"""
        return _coin.SoNodeKitListPart_insertChild(self, *args)

    def getChild(self, *args):
        """getChild(self, int index) -> SoNode"""
        return _coin.SoNodeKitListPart_getChild(self, *args)

    def findChild(self, *args):
        """findChild(self, SoNode child) -> int"""
        return _coin.SoNodeKitListPart_findChild(self, *args)

    def getNumChildren(self):
        """getNumChildren(self) -> int"""
        return _coin.SoNodeKitListPart_getNumChildren(self)

    def removeChild(self, *args):
        """
        removeChild(self, int index)
        removeChild(self, SoNode child)
        """
        return _coin.SoNodeKitListPart_removeChild(self, *args)

    def replaceChild(self, *args):
        """
        replaceChild(self, int index, SoNode newChild)
        replaceChild(self, SoNode oldChild, SoNode newChild)
        """
        return _coin.SoNodeKitListPart_replaceChild(self, *args)

    def affectsState(self):
        """affectsState(self) -> SbBool"""
        return _coin.SoNodeKitListPart_affectsState(self)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoNodeKitListPart_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoNodeKitListPart_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoNodeKitListPart_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoNodeKitListPart_getBoundingBox(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoNodeKitListPart_getMatrix(self, *args)

    def handleEvent(self, *args):
        """handleEvent(self, SoHandleEventAction action)"""
        return _coin.SoNodeKitListPart_handleEvent(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoNodeKitListPart_pick(self, *args)

    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoNodeKitListPart_search(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoNodeKitListPart_getPrimitiveCount(self, *args)

    def getChildren(self):
        """getChildren(self) -> SoChildList"""
        return _coin.SoNodeKitListPart_getChildren(self)

SoNodeKitListPart_swigregister = _coin.SoNodeKitListPart_swigregister
SoNodeKitListPart_swigregister(SoNodeKitListPart)

def SoNodeKitListPart_getClassTypeId():
  """SoNodeKitListPart_getClassTypeId() -> SoType"""
  return _coin.SoNodeKitListPart_getClassTypeId()

def SoNodeKitListPart_initClass():
  """SoNodeKitListPart_initClass()"""
  return _coin.SoNodeKitListPart_initClass()

class SoNodeKitPath(SoPath):
    """Proxy of C++ SoNodeKitPath class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getLength(self):
        """getLength(self) -> int"""
        return _coin.SoNodeKitPath_getLength(self)

    def getTail(self):
        """getTail(self) -> SoNode"""
        return _coin.SoNodeKitPath_getTail(self)

    def getNode(self, *args):
        """getNode(self, int idx) -> SoNode"""
        return _coin.SoNodeKitPath_getNode(self, *args)

    def getNodeFromTail(self, *args):
        """getNodeFromTail(self, int idx) -> SoNode"""
        return _coin.SoNodeKitPath_getNodeFromTail(self, *args)

    def truncate(self, *args):
        """truncate(self, int length)"""
        return _coin.SoNodeKitPath_truncate(self, *args)

    def pop(self):
        """pop(self)"""
        return _coin.SoNodeKitPath_pop(self)

    def append(self, *args):
        """
        append(self, SoBaseKit childKit)
        append(self, SoNodeKitPath fromPath)
        """
        return _coin.SoNodeKitPath_append(self, *args)

    def containsNode(self, *args):
        """containsNode(self, SoBaseKit node) -> SbBool"""
        return _coin.SoNodeKitPath_containsNode(self, *args)

    def findFork(self, *args):
        """findFork(self, SoNodeKitPath path) -> int"""
        return _coin.SoNodeKitPath_findFork(self, *args)

    def __iter__(self):
       for i in range(self.getLength()):
          yield self.getNode(i)
          
    def index(self):
       for i in range(self.getLength()):
          yield self.getIndex(i)

    def __eq__(self, *args):
        """__eq__(self, SoNodeKitPath u) -> int"""
        return _coin.SoNodeKitPath___eq__(self, *args)

    def __nq__(self, *args):
        """__nq__(self, SoNodeKitPath u) -> int"""
        return _coin.SoNodeKitPath___nq__(self, *args)

SoNodeKitPath_swigregister = _coin.SoNodeKitPath_swigregister
SoNodeKitPath_swigregister(SoNodeKitPath)

class SoChildList(SoNodeList):
    """Proxy of C++ SoChildList class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, SoNode parent) -> SoChildList
        __init__(self, SoNode parent, int size) -> SoChildList
        __init__(self, SoNode parent, SoChildList cl) -> SoChildList
        """
        this = _coin.new_SoChildList(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoChildList
    __del__ = lambda self : None;
    def append(self, *args):
        """append(self, SoNode node)"""
        return _coin.SoChildList_append(self, *args)

    def insert(self, *args):
        """insert(self, SoNode ptr, int addbefore)"""
        return _coin.SoChildList_insert(self, *args)

    def remove(self, *args):
        """remove(self, int index)"""
        return _coin.SoChildList_remove(self, *args)

    def truncate(self, *args):
        """truncate(self, int length)"""
        return _coin.SoChildList_truncate(self, *args)

    def copy(self, *args):
        """copy(self, SoChildList cl)"""
        return _coin.SoChildList_copy(self, *args)

    def set(self, *args):
        """set(self, int index, SoNode node)"""
        return _coin.SoChildList_set(self, *args)

    def traverseInPath(self, *args):
        """traverseInPath(self, SoAction action, int numindices, int indices)"""
        return _coin.SoChildList_traverseInPath(self, *args)

    def traverse(self, *args):
        """
        traverse(self, SoAction action)
        traverse(self, SoAction action, int index)
        traverse(self, SoAction action, SoNode node)
        traverse(self, SoAction action, int first, int last)
        """
        return _coin.SoChildList_traverse(self, *args)

    def addPathAuditor(self, *args):
        """addPathAuditor(self, SoPath path)"""
        return _coin.SoChildList_addPathAuditor(self, *args)

    def removePathAuditor(self, *args):
        """removePathAuditor(self, SoPath path)"""
        return _coin.SoChildList_removePathAuditor(self, *args)

SoChildList_swigregister = _coin.SoChildList_swigregister
SoChildList_swigregister(SoChildList)

class SoBaseKit(SoNode):
    """Proxy of C++ SoBaseKit class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoBaseKit_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoBaseKit_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoBaseKit_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoBaseKit"""
        this = _coin.new_SoBaseKit()
        try: self.this.append(this)
        except: self.this = this
    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoBaseKit_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoBaseKit_getNodekitCatalog(self)

    def getPart(self, *args):
        """getPart(self, SbName partname, SbBool makeifneeded) -> SoNode"""
        return _coin.SoBaseKit_getPart(self, *args)

    def getPartString(self, *args):
        """getPartString(self, SoBase part) -> SbString"""
        return _coin.SoBaseKit_getPartString(self, *args)

    def createPathToPart(self, *args):
        """
        createPathToPart(self, SbName partname, SbBool makeifneeded, SoPath pathtoextend = None) -> SoNodeKitPath
        createPathToPart(self, SbName partname, SbBool makeifneeded) -> SoNodeKitPath
        """
        return _coin.SoBaseKit_createPathToPart(self, *args)

    def setPart(self, *args):
        """setPart(self, SbName partname, SoNode srcFrom) -> SbBool"""
        return _coin.SoBaseKit_setPart(self, *args)

    def set(self, *args):
        """
        set(self, char namevaluepairliststring) -> SbBool
        set(self, char partnamestring, char parameterstring) -> SbBool
        """
        return _coin.SoBaseKit_set(self, *args)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoBaseKit_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoBaseKit_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoBaseKit_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoBaseKit_getBoundingBox(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoBaseKit_getMatrix(self, *args)

    def handleEvent(self, *args):
        """handleEvent(self, SoHandleEventAction action)"""
        return _coin.SoBaseKit_handleEvent(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoBaseKit_rayPick(self, *args)

    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoBaseKit_search(self, *args)

    def write(self, *args):
        """write(self, SoWriteAction action)"""
        return _coin.SoBaseKit_write(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoBaseKit_getPrimitiveCount(self, *args)

    def getChildren(self):
        """getChildren(self) -> SoChildList"""
        return _coin.SoBaseKit_getChildren(self)

    def printDiagram(self):
        """printDiagram(self)"""
        return _coin.SoBaseKit_printDiagram(self)

    def printSubDiagram(self, *args):
        """printSubDiagram(self, SbName rootname, int level)"""
        return _coin.SoBaseKit_printSubDiagram(self, *args)

    def printTable(self):
        """printTable(self)"""
        return _coin.SoBaseKit_printTable(self)

    def addWriteReference(self, *args):
        """
        addWriteReference(self, SoOutput out, SbBool isfromfield = 0)
        addWriteReference(self, SoOutput out)
        """
        return _coin.SoBaseKit_addWriteReference(self, *args)

    def forceChildDrivenWriteRefs(self, *args):
        """forceChildDrivenWriteRefs(self, SoOutput out) -> SbBool"""
        return _coin.SoBaseKit_forceChildDrivenWriteRefs(self, *args)

    def isSearchingChildren():
        """isSearchingChildren() -> SbBool"""
        return _coin.SoBaseKit_isSearchingChildren()

    isSearchingChildren = staticmethod(isSearchingChildren)
    def setSearchingChildren(*args):
        """setSearchingChildren(SbBool newval)"""
        return _coin.SoBaseKit_setSearchingChildren(*args)

    setSearchingChildren = staticmethod(setSearchingChildren)
    def __getattr__(self,name):
       c = _coin.SoBaseKit_getNodekitCatalog(self)
       if c.getPartNumber(name) >= 0:
           part = self.getPart(name,1)
           return part
       return SoNode.__getattr__(self, name)

    def __setattr__(self,name,value):
       if name == 'this':
          return SoNode.__setattr__(self,name,value)
       c = _coin.SoBaseKit_getNodekitCatalog(self)
       if c.getPartNumber(name) >= 0:
          return self.setPart(name, value)
       return SoNode.__setattr__(self,name,value)       

SoBaseKit_swigregister = _coin.SoBaseKit_swigregister
SoBaseKit_swigregister(SoBaseKit)

def SoBaseKit_getClassTypeId():
  """SoBaseKit_getClassTypeId() -> SoType"""
  return _coin.SoBaseKit_getClassTypeId()

def SoBaseKit_initClass():
  """SoBaseKit_initClass()"""
  return _coin.SoBaseKit_initClass()

def SoBaseKit_getClassNodekitCatalog():
  """SoBaseKit_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoBaseKit_getClassNodekitCatalog()

def SoBaseKit_isSearchingChildren():
  """SoBaseKit_isSearchingChildren() -> SbBool"""
  return _coin.SoBaseKit_isSearchingChildren()

def SoBaseKit_setSearchingChildren(*args):
  """SoBaseKit_setSearchingChildren(SbBool newval)"""
  return _coin.SoBaseKit_setSearchingChildren(*args)

class SoSensor(object):
    """Proxy of C++ SoSensor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _coin.delete_SoSensor
    __del__ = lambda self : None;
    def setFunction(self, *args):
        """setFunction(self, SoSensorCB callbackfunction)"""
        return _coin.SoSensor_setFunction(self, *args)

    def getFunction(self):
        """getFunction(self) -> SoSensorCBPtr"""
        return _coin.SoSensor_getFunction(self)

    def setData(self, *args):
        """setData(self, void callbackdata)"""
        return _coin.SoSensor_setData(self, *args)

    def getData(self):
        """getData(self) -> void"""
        return _coin.SoSensor_getData(self)

    def schedule(self):
        """schedule(self)"""
        return _coin.SoSensor_schedule(self)

    def unschedule(self):
        """unschedule(self)"""
        return _coin.SoSensor_unschedule(self)

    def isScheduled(self):
        """isScheduled(self) -> SbBool"""
        return _coin.SoSensor_isScheduled(self)

    def trigger(self):
        """trigger(self)"""
        return _coin.SoSensor_trigger(self)

    def isBefore(self, *args):
        """isBefore(self, SoSensor s) -> SbBool"""
        return _coin.SoSensor_isBefore(self, *args)

    def setNextInQueue(self, *args):
        """setNextInQueue(self, SoSensor next)"""
        return _coin.SoSensor_setNextInQueue(self, *args)

    def getNextInQueue(self):
        """getNextInQueue(self) -> SoSensor"""
        return _coin.SoSensor_getNextInQueue(self)

    def initClass():
        """initClass()"""
        return _coin.SoSensor_initClass()

    initClass = staticmethod(initClass)
SoSensor_swigregister = _coin.SoSensor_swigregister
SoSensor_swigregister(SoSensor)

def SoSensor_initClass():
  """SoSensor_initClass()"""
  return _coin.SoSensor_initClass()

class SoDelayQueueSensor(SoSensor):
    """Proxy of C++ SoDelayQueueSensor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
       newobj = None
       if len(args) == 2:
          args = (args[0], (args[0], args[1], "SoDelayQueueSensor *"))
          newobj = apply(_coin.new_SoDelayQueueSensor_scb_v, args)
       else:
          newobj = apply(_coin.new_SoDelayQueueSensor, args)
       if newobj:
          self.this = newobj.this
          self.thisown = 1


    __swig_destroy__ = _coin.delete_SoDelayQueueSensor
    __del__ = lambda self : None;
    def setPriority(self, *args):
        """setPriority(self, uint32_t pri)"""
        return _coin.SoDelayQueueSensor_setPriority(self, *args)

    def getPriority(self):
        """getPriority(self) -> uint32_t"""
        return _coin.SoDelayQueueSensor_getPriority(self)

    def getDefaultPriority():
        """getDefaultPriority() -> uint32_t"""
        return _coin.SoDelayQueueSensor_getDefaultPriority()

    getDefaultPriority = staticmethod(getDefaultPriority)
    def schedule(self):
        """schedule(self)"""
        return _coin.SoDelayQueueSensor_schedule(self)

    def unschedule(self):
        """unschedule(self)"""
        return _coin.SoDelayQueueSensor_unschedule(self)

    def isScheduled(self):
        """isScheduled(self) -> SbBool"""
        return _coin.SoDelayQueueSensor_isScheduled(self)

    def isIdleOnly(self):
        """isIdleOnly(self) -> SbBool"""
        return _coin.SoDelayQueueSensor_isIdleOnly(self)

    def trigger(self):
        """trigger(self)"""
        return _coin.SoDelayQueueSensor_trigger(self)

SoDelayQueueSensor_swigregister = _coin.SoDelayQueueSensor_swigregister
SoDelayQueueSensor_swigregister(SoDelayQueueSensor)
def __init__(self, *args):
   newobj = None
   if len(args) == 2:
      args = (args[0], (args[0], args[1], "SoDelayQueueSensor *"))
      newobj = apply(_coin.new_SoDelayQueueSensor_scb_v, args)
   else:
      newobj = apply(_coin.new_SoDelayQueueSensor, args)
   if newobj:
      self.this = newobj.this
      self.thisown = 1



def SoDelayQueueSensor_getDefaultPriority():
  """SoDelayQueueSensor_getDefaultPriority() -> uint32_t"""
  return _coin.SoDelayQueueSensor_getDefaultPriority()

class SoDataSensor(SoDelayQueueSensor):
    """Proxy of C++ SoDataSensor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _coin.delete_SoDataSensor
    __del__ = lambda self : None;
    def setDeleteCallback(self, *args):
        """
        setDeleteCallback(self, SoSensorCB function, void data = None)
        setDeleteCallback(self, SoSensorCB function)
        """
        return _coin.SoDataSensor_setDeleteCallback(self, *args)

    def getTriggerNode(self):
        """getTriggerNode(self) -> SoNode"""
        return _coin.SoDataSensor_getTriggerNode(self)

    def getTriggerField(self):
        """getTriggerField(self) -> SoField"""
        return _coin.SoDataSensor_getTriggerField(self)

    def getTriggerPath(self):
        """getTriggerPath(self) -> SoPath"""
        return _coin.SoDataSensor_getTriggerPath(self)

    def setTriggerPathFlag(self, *args):
        """setTriggerPathFlag(self, SbBool flag)"""
        return _coin.SoDataSensor_setTriggerPathFlag(self, *args)

    def getTriggerPathFlag(self):
        """getTriggerPathFlag(self) -> SbBool"""
        return _coin.SoDataSensor_getTriggerPathFlag(self)

    def trigger(self):
        """trigger(self)"""
        return _coin.SoDataSensor_trigger(self)

    def notify(self, *args):
        """notify(self, SoNotList l)"""
        return _coin.SoDataSensor_notify(self, *args)

    def dyingReference(self):
        """dyingReference(self)"""
        return _coin.SoDataSensor_dyingReference(self)

SoDataSensor_swigregister = _coin.SoDataSensor_swigregister
SoDataSensor_swigregister(SoDataSensor)

class SoFieldSensor(SoDataSensor):
    """Proxy of C++ SoFieldSensor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
       newobj = None
       if len(args) == 2:
          args = (args[0], (args[0], args[1], "SoFieldSensor *"))
          newobj = apply(_coin.new_SoFieldSensor_scb_v, args)
       else:
          newobj = apply(_coin.new_SoFieldSensor, args)
       if newobj:
          self.this = newobj.this
          self.thisown = 1


    __swig_destroy__ = _coin.delete_SoFieldSensor
    __del__ = lambda self : None;
    def attach(self, *args):
        """attach(self, SoField field)"""
        return _coin.SoFieldSensor_attach(self, *args)

    def detach(self):
        """detach(self)"""
        return _coin.SoFieldSensor_detach(self)

    def getAttachedField(self):
        """getAttachedField(self) -> SoField"""
        return _coin.SoFieldSensor_getAttachedField(self)

    def trigger(self):
        """trigger(self)"""
        return _coin.SoFieldSensor_trigger(self)

SoFieldSensor_swigregister = _coin.SoFieldSensor_swigregister
SoFieldSensor_swigregister(SoFieldSensor)
def __init__(self, *args):
   newobj = None
   if len(args) == 2:
      args = (args[0], (args[0], args[1], "SoFieldSensor *"))
      newobj = apply(_coin.new_SoFieldSensor_scb_v, args)
   else:
      newobj = apply(_coin.new_SoFieldSensor, args)
   if newobj:
      self.this = newobj.this
      self.thisown = 1



class SoInteractionKit(SoBaseKit):
    """Proxy of C++ SoInteractionKit class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoInteractionKit_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoInteractionKit_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoInteractionKit_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoInteractionKit_getNodekitCatalog(self)

    renderCaching = _swig_property(_coin.SoInteractionKit_renderCaching_get, _coin.SoInteractionKit_renderCaching_set)
    boundingBoxCaching = _swig_property(_coin.SoInteractionKit_boundingBoxCaching_get, _coin.SoInteractionKit_boundingBoxCaching_set)
    renderCulling = _swig_property(_coin.SoInteractionKit_renderCulling_get, _coin.SoInteractionKit_renderCulling_set)
    pickCulling = _swig_property(_coin.SoInteractionKit_pickCulling_get, _coin.SoInteractionKit_pickCulling_set)
    def __init__(self): 
        """__init__(self) -> SoInteractionKit"""
        this = _coin.new_SoInteractionKit()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoInteractionKit_initClass()

    initClass = staticmethod(initClass)
    OFF = _coin.SoInteractionKit_OFF
    ON = _coin.SoInteractionKit_ON
    AUTO = _coin.SoInteractionKit_AUTO
    def setPartAsPath(self, *args):
        """setPartAsPath(self, SbName partname, SoPath path) -> SbBool"""
        return _coin.SoInteractionKit_setPartAsPath(self, *args)

    def setPartAsDefault(self, *args):
        """
        setPartAsDefault(self, SbName partname, SoNode node, SbBool onlyifdefault = 1) -> SbBool
        setPartAsDefault(self, SbName partname, SoNode node) -> SbBool
        setPartAsDefault(self, SbName partname, SbName nodename, SbBool onlyifdefault = 1) -> SbBool
        setPartAsDefault(self, SbName partname, SbName nodename) -> SbBool
        """
        return _coin.SoInteractionKit_setPartAsDefault(self, *args)

    def isPathSurrogateInMySubgraph(self, *args):
        """
        isPathSurrogateInMySubgraph(self, SoPath path, SoPath pathToOwner, SbName surrogatename, 
            SoPath surrogatepath, SbBool fillargs = 1) -> SbBool
        isPathSurrogateInMySubgraph(self, SoPath path, SoPath pathToOwner, SbName surrogatename, 
            SoPath surrogatepath) -> SbBool
        isPathSurrogateInMySubgraph(self, SoPath path) -> SbBool
        """
        return _coin.SoInteractionKit_isPathSurrogateInMySubgraph(self, *args)

    def setSwitchValue(*args):
        """setSwitchValue(SoNode node, int newVal)"""
        return _coin.SoInteractionKit_setSwitchValue(*args)

    setSwitchValue = staticmethod(setSwitchValue)
    def setPart(self, *args):
        """setPart(self, SbName partname, SoNode srcFrom) -> SbBool"""
        return _coin.SoInteractionKit_setPart(self, *args)

SoInteractionKit_swigregister = _coin.SoInteractionKit_swigregister
SoInteractionKit_swigregister(SoInteractionKit)

def SoInteractionKit_getClassTypeId():
  """SoInteractionKit_getClassTypeId() -> SoType"""
  return _coin.SoInteractionKit_getClassTypeId()

def SoInteractionKit_getClassNodekitCatalog():
  """SoInteractionKit_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoInteractionKit_getClassNodekitCatalog()

def SoInteractionKit_initClass():
  """SoInteractionKit_initClass()"""
  return _coin.SoInteractionKit_initClass()

def SoInteractionKit_setSwitchValue(*args):
  """SoInteractionKit_setSwitchValue(SoNode node, int newVal)"""
  return _coin.SoInteractionKit_setSwitchValue(*args)

class SoCallbackList(object):
    """Proxy of C++ SoCallbackList class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoCallbackList"""
        this = _coin.new_SoCallbackList()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoCallbackList
    __del__ = lambda self : None;
    def addCallback(self, *args):
        """
        addCallback(self, SoCallbackListCB f, void userData = None)
        addCallback(self, SoCallbackListCB f)
        """
        return _coin.SoCallbackList_addCallback(self, *args)

    def removeCallback(self, *args):
        """
        removeCallback(self, SoCallbackListCB f, void userdata = None)
        removeCallback(self, SoCallbackListCB f)
        """
        return _coin.SoCallbackList_removeCallback(self, *args)

    def clearCallbacks(self):
        """clearCallbacks(self)"""
        return _coin.SoCallbackList_clearCallbacks(self)

    def getNumCallbacks(self):
        """getNumCallbacks(self) -> int"""
        return _coin.SoCallbackList_getNumCallbacks(self)

    def invokeCallbacks(self, *args):
        """invokeCallbacks(self, void callbackdata)"""
        return _coin.SoCallbackList_invokeCallbacks(self, *args)

SoCallbackList_swigregister = _coin.SoCallbackList_swigregister
SoCallbackList_swigregister(SoCallbackList)

class SbVec3d(object):
    """Proxy of C++ SbVec3d class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbVec3d
        __init__(self, double v) -> SbVec3d
        __init__(self, double x, double y, double z) -> SbVec3d
        __init__(self, SbVec3f v) -> SbVec3d
        __init__(self, SbVec3b v) -> SbVec3d
        __init__(self, SbVec3s v) -> SbVec3d
        __init__(self, SbVec3i32 v) -> SbVec3d
        __init__(self, SbDPPlane p0, SbDPPlane p1, SbDPPlane p2) -> SbVec3d
        """
        this = _coin.new_SbVec3d(*args)
        try: self.this.append(this)
        except: self.this = this
    def setValue(self, *args):
        """
        setValue(self, double v) -> SbVec3d
        setValue(self, double x, double y, double z) -> SbVec3d
        setValue(self, SbVec3d barycentric, SbVec3d v0, SbVec3d v1, SbVec3d v2) -> SbVec3d
        setValue(self, SbVec3f v) -> SbVec3d
        setValue(self, SbVec3b v) -> SbVec3d
        setValue(self, SbVec3s v) -> SbVec3d
        setValue(self, SbVec3i32 v) -> SbVec3d
        """
        return _coin.SbVec3d_setValue(self, *args)

    def getValue(self):
        """getValue(self) -> double"""
        return _coin.SbVec3d_getValue(self)

    def cross(self, *args):
        """cross(self, SbVec3d v) -> SbVec3d"""
        return _coin.SbVec3d_cross(self, *args)

    def dot(self, *args):
        """dot(self, SbVec3d v) -> double"""
        return _coin.SbVec3d_dot(self, *args)

    def equals(self, *args):
        """equals(self, SbVec3d v, double tolerance) -> SbBool"""
        return _coin.SbVec3d_equals(self, *args)

    def getClosestAxis(self):
        """getClosestAxis(self) -> SbVec3d"""
        return _coin.SbVec3d_getClosestAxis(self)

    def length(self):
        """length(self) -> double"""
        return _coin.SbVec3d_length(self)

    def sqrLength(self):
        """sqrLength(self) -> double"""
        return _coin.SbVec3d_sqrLength(self)

    def negate(self):
        """negate(self)"""
        return _coin.SbVec3d_negate(self)

    def normalize(self):
        """normalize(self) -> double"""
        return _coin.SbVec3d_normalize(self)

    def __imul__(self, *args):
        """__imul__(self, double d) -> SbVec3d"""
        return _coin.SbVec3d___imul__(self, *args)

    def __idiv__(self, *args):
        """__idiv__(self, double d) -> SbVec3d"""
        return _coin.SbVec3d___idiv__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, SbVec3d v) -> SbVec3d"""
        return _coin.SbVec3d___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, SbVec3d v) -> SbVec3d"""
        return _coin.SbVec3d___isub__(self, *args)

    def __neg__(self):
        """__neg__(self) -> SbVec3d"""
        return _coin.SbVec3d___neg__(self)

    def output(self, *args):
        """output(self, FILE fp)"""
        return _coin.SbVec3d_output(self, *args)

    def __add__(self, *args):
        """__add__(self, SbVec3d u) -> SbVec3d"""
        return _coin.SbVec3d___add__(self, *args)

    def __sub__(self, *args):
        """__sub__(self, SbVec3d u) -> SbVec3d"""
        return _coin.SbVec3d___sub__(self, *args)

    def __mul__(self, *args):
        """
        __mul__(self, double d) -> SbVec3d
        __mul__(self, SbDPMatrix m) -> SbVec3d
        """
        return _coin.SbVec3d___mul__(self, *args)

    def __rmul__(self, *args):
        """__rmul__(self, double d) -> SbVec3d"""
        return _coin.SbVec3d___rmul__(self, *args)

    def __div__(self, *args):
        """__div__(self, double d) -> SbVec3d"""
        return _coin.SbVec3d___div__(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SbVec3d u) -> int"""
        return _coin.SbVec3d___eq__(self, *args)

    def __nq__(self, *args):
        """__nq__(self, SbVec3d u) -> int"""
        return _coin.SbVec3d___nq__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> double"""
        return _coin.SbVec3d___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, double value)"""
        return _coin.SbVec3d___setitem__(self, *args)

    def __iter__(self):
       for i in range(3):
          yield self[i]
       
    def __len__(self):
          return 3

    __swig_destroy__ = _coin.delete_SbVec3d
    __del__ = lambda self : None;
SbVec3d_swigregister = _coin.SbVec3d_swigregister
SbVec3d_swigregister(SbVec3d)

class SbDPViewVolume(object):
    """Proxy of C++ SbDPViewVolume class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ORTHOGRAPHIC = _coin.SbDPViewVolume_ORTHOGRAPHIC
    PERSPECTIVE = _coin.SbDPViewVolume_PERSPECTIVE
    def __init__(self): 
        """__init__(self) -> SbDPViewVolume"""
        this = _coin.new_SbDPViewVolume()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SbDPViewVolume
    __del__ = lambda self : None;
    def getMatrices(self, *args):
        """getMatrices(self, SbDPMatrix affine, SbDPMatrix proj)"""
        return _coin.SbDPViewVolume_getMatrices(self, *args)

    def getMatrix(self):
        """getMatrix(self) -> SbDPMatrix"""
        return _coin.SbDPViewVolume_getMatrix(self)

    def getCameraSpaceMatrix(self):
        """getCameraSpaceMatrix(self) -> SbDPMatrix"""
        return _coin.SbDPViewVolume_getCameraSpaceMatrix(self)

    def projectPointToLine(self, *args):
        """
        projectPointToLine(self, SbVec2d pt, SbDPLine line)
        projectPointToLine(self, SbVec2d pt, SbVec3d line0, SbVec3d line1)
        """
        return _coin.SbDPViewVolume_projectPointToLine(self, *args)

    def projectToScreen(self, *args):
        """projectToScreen(self, SbVec3d src, SbVec3d dst)"""
        return _coin.SbDPViewVolume_projectToScreen(self, *args)

    def getPlane(self, *args):
        """getPlane(self, double distFromEye) -> SbPlane"""
        return _coin.SbDPViewVolume_getPlane(self, *args)

    def getSightPoint(self, *args):
        """getSightPoint(self, double distFromEye) -> SbVec3d"""
        return _coin.SbDPViewVolume_getSightPoint(self, *args)

    def getPlanePoint(self, *args):
        """getPlanePoint(self, double distFromEye, SbVec2d normPoint) -> SbVec3d"""
        return _coin.SbDPViewVolume_getPlanePoint(self, *args)

    def getAlignRotation(self, rightAngleOnly = 0):
        """
        getAlignRotation(self, SbBool rightAngleOnly = 0) -> SbDPRotation
        getAlignRotation(self) -> SbDPRotation
        """
        return _coin.SbDPViewVolume_getAlignRotation(self, rightAngleOnly)

    def getWorldToScreenScale(self, *args):
        """getWorldToScreenScale(self, SbVec3d worldCenter, double normRadius) -> double"""
        return _coin.SbDPViewVolume_getWorldToScreenScale(self, *args)

    def projectBox(self, *args):
        """projectBox(self, SbBox3f box) -> SbVec2d"""
        return _coin.SbDPViewVolume_projectBox(self, *args)

    def narrow(self, *args):
        """
        narrow(self, double left, double bottom, double right, double top) -> SbDPViewVolume
        narrow(self, SbBox3f box) -> SbDPViewVolume
        """
        return _coin.SbDPViewVolume_narrow(self, *args)

    def ortho(self, *args):
        """
        ortho(self, double left, double right, double bottom, double top, 
            double nearval, double farval)
        """
        return _coin.SbDPViewVolume_ortho(self, *args)

    def perspective(self, *args):
        """perspective(self, double fovy, double aspect, double nearval, double farval)"""
        return _coin.SbDPViewVolume_perspective(self, *args)

    def frustum(self, *args):
        """
        frustum(self, double left, double right, double bottom, double top, 
            double nearval, double farval)
        """
        return _coin.SbDPViewVolume_frustum(self, *args)

    def rotateCamera(self, *args):
        """rotateCamera(self, SbDPRotation q)"""
        return _coin.SbDPViewVolume_rotateCamera(self, *args)

    def translateCamera(self, *args):
        """translateCamera(self, SbVec3d v)"""
        return _coin.SbDPViewVolume_translateCamera(self, *args)

    def zVector(self):
        """zVector(self) -> SbVec3d"""
        return _coin.SbDPViewVolume_zVector(self)

    def zNarrow(self, *args):
        """zNarrow(self, double nearval, double farval) -> SbDPViewVolume"""
        return _coin.SbDPViewVolume_zNarrow(self, *args)

    def scale(self, *args):
        """scale(self, double factor)"""
        return _coin.SbDPViewVolume_scale(self, *args)

    def scaleWidth(self, *args):
        """scaleWidth(self, double ratio)"""
        return _coin.SbDPViewVolume_scaleWidth(self, *args)

    def scaleHeight(self, *args):
        """scaleHeight(self, double ratio)"""
        return _coin.SbDPViewVolume_scaleHeight(self, *args)

    def getProjectionType(self):
        """getProjectionType(self) -> ProjectionType"""
        return _coin.SbDPViewVolume_getProjectionType(self)

    def getProjectionPoint(self):
        """getProjectionPoint(self) -> SbVec3d"""
        return _coin.SbDPViewVolume_getProjectionPoint(self)

    def getProjectionDirection(self):
        """getProjectionDirection(self) -> SbVec3d"""
        return _coin.SbDPViewVolume_getProjectionDirection(self)

    def getNearDist(self):
        """getNearDist(self) -> double"""
        return _coin.SbDPViewVolume_getNearDist(self)

    def getWidth(self):
        """getWidth(self) -> double"""
        return _coin.SbDPViewVolume_getWidth(self)

    def getHeight(self):
        """getHeight(self) -> double"""
        return _coin.SbDPViewVolume_getHeight(self)

    def getDepth(self):
        """getDepth(self) -> double"""
        return _coin.SbDPViewVolume_getDepth(self)

    def output(self, *args):
        """output(self, FILE fp)"""
        return _coin.SbDPViewVolume_output(self, *args)

    def getViewVolumePlanes(self, *args):
        """getViewVolumePlanes(self, SbPlane planes)"""
        return _coin.SbDPViewVolume_getViewVolumePlanes(self, *args)

    def transform(self, *args):
        """transform(self, SbDPMatrix matrix)"""
        return _coin.SbDPViewVolume_transform(self, *args)

    def getViewUp(self):
        """getViewUp(self) -> SbVec3d"""
        return _coin.SbDPViewVolume_getViewUp(self)

    def copyValues(self, *args):
        """copyValues(self, SbViewVolume vv)"""
        return _coin.SbDPViewVolume_copyValues(self, *args)

SbDPViewVolume_swigregister = _coin.SbDPViewVolume_swigregister
SbDPViewVolume_swigregister(SbDPViewVolume)

class SbViewVolume(object):
    """Proxy of C++ SbViewVolume class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ORTHOGRAPHIC = _coin.SbViewVolume_ORTHOGRAPHIC
    PERSPECTIVE = _coin.SbViewVolume_PERSPECTIVE
    def __init__(self): 
        """__init__(self) -> SbViewVolume"""
        this = _coin.new_SbViewVolume()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SbViewVolume
    __del__ = lambda self : None;
    def getMatrices(self, *args):
        """getMatrices(self, SbMatrix affine, SbMatrix proj)"""
        return _coin.SbViewVolume_getMatrices(self, *args)

    def getMatrix(self):
        """getMatrix(self) -> SbMatrix"""
        return _coin.SbViewVolume_getMatrix(self)

    def getCameraSpaceMatrix(self):
        """getCameraSpaceMatrix(self) -> SbMatrix"""
        return _coin.SbViewVolume_getCameraSpaceMatrix(self)

    def getPlane(self, *args):
        """getPlane(self, float distFromEye) -> SbPlane"""
        return _coin.SbViewVolume_getPlane(self, *args)

    def getSightPoint(self, *args):
        """getSightPoint(self, float distFromEye) -> SbVec3f"""
        return _coin.SbViewVolume_getSightPoint(self, *args)

    def getPlanePoint(self, *args):
        """getPlanePoint(self, float distFromEye, SbVec2f normPoint) -> SbVec3f"""
        return _coin.SbViewVolume_getPlanePoint(self, *args)

    def getAlignRotation(self, rightAngleOnly = 0):
        """
        getAlignRotation(self, SbBool rightAngleOnly = 0) -> SbRotation
        getAlignRotation(self) -> SbRotation
        """
        return _coin.SbViewVolume_getAlignRotation(self, rightAngleOnly)

    def getWorldToScreenScale(self, *args):
        """getWorldToScreenScale(self, SbVec3f worldCenter, float normRadius) -> float"""
        return _coin.SbViewVolume_getWorldToScreenScale(self, *args)

    def projectBox(self, *args):
        """projectBox(self, SbBox3f box) -> SbVec2f"""
        return _coin.SbViewVolume_projectBox(self, *args)

    def narrow(self, *args):
        """
        narrow(self, float left, float bottom, float right, float top) -> SbViewVolume
        narrow(self, SbBox3f box) -> SbViewVolume
        """
        return _coin.SbViewVolume_narrow(self, *args)

    def ortho(self, *args):
        """
        ortho(self, float left, float right, float bottom, float top, float nearval, 
            float farval)
        """
        return _coin.SbViewVolume_ortho(self, *args)

    def perspective(self, *args):
        """perspective(self, float fovy, float aspect, float nearval, float farval)"""
        return _coin.SbViewVolume_perspective(self, *args)

    def frustum(self, *args):
        """
        frustum(self, float left, float right, float bottom, float top, float nearval, 
            float farval)
        """
        return _coin.SbViewVolume_frustum(self, *args)

    def rotateCamera(self, *args):
        """rotateCamera(self, SbRotation q)"""
        return _coin.SbViewVolume_rotateCamera(self, *args)

    def translateCamera(self, *args):
        """translateCamera(self, SbVec3f v)"""
        return _coin.SbViewVolume_translateCamera(self, *args)

    def zVector(self):
        """zVector(self) -> SbVec3f"""
        return _coin.SbViewVolume_zVector(self)

    def zNarrow(self, *args):
        """zNarrow(self, float nearval, float farval) -> SbViewVolume"""
        return _coin.SbViewVolume_zNarrow(self, *args)

    def scale(self, *args):
        """scale(self, float factor)"""
        return _coin.SbViewVolume_scale(self, *args)

    def scaleWidth(self, *args):
        """scaleWidth(self, float ratio)"""
        return _coin.SbViewVolume_scaleWidth(self, *args)

    def scaleHeight(self, *args):
        """scaleHeight(self, float ratio)"""
        return _coin.SbViewVolume_scaleHeight(self, *args)

    def getProjectionType(self):
        """getProjectionType(self) -> ProjectionType"""
        return _coin.SbViewVolume_getProjectionType(self)

    def getProjectionPoint(self):
        """getProjectionPoint(self) -> SbVec3f"""
        return _coin.SbViewVolume_getProjectionPoint(self)

    def getProjectionDirection(self):
        """getProjectionDirection(self) -> SbVec3f"""
        return _coin.SbViewVolume_getProjectionDirection(self)

    def getNearDist(self):
        """getNearDist(self) -> float"""
        return _coin.SbViewVolume_getNearDist(self)

    def getWidth(self):
        """getWidth(self) -> float"""
        return _coin.SbViewVolume_getWidth(self)

    def getHeight(self):
        """getHeight(self) -> float"""
        return _coin.SbViewVolume_getHeight(self)

    def getDepth(self):
        """getDepth(self) -> float"""
        return _coin.SbViewVolume_getDepth(self)

    def output(self, *args):
        """output(self, FILE fp)"""
        return _coin.SbViewVolume_output(self, *args)

    def getViewVolumePlanes(self, *args):
        """getViewVolumePlanes(self, SbPlane planes)"""
        return _coin.SbViewVolume_getViewVolumePlanes(self, *args)

    def transform(self):
        """transform(self)"""
        return _coin.SbViewVolume_transform(self)

    def getViewUp(self):
        """getViewUp(self) -> SbVec3f"""
        return _coin.SbViewVolume_getViewUp(self)

    def intersect(self, *args):
        """
        intersect(self, SbVec3f p) -> SbBool
        intersect(self, SbVec3f p0, SbVec3f p1, SbVec3f closestpoint) -> SbBool
        intersect(self, SbBox3f box) -> SbBool
        """
        return _coin.SbViewVolume_intersect(self, *args)

    def outsideTest(self, *args):
        """outsideTest(self, SbPlane p, SbVec3f bmin, SbVec3f bmax) -> SbBool"""
        return _coin.SbViewVolume_outsideTest(self, *args)

    def getDPViewVolume(self):
        """getDPViewVolume(self) -> SbDPViewVolume"""
        return _coin.SbViewVolume_getDPViewVolume(self)

    type = _swig_property(_coin.SbViewVolume_type_get, _coin.SbViewVolume_type_set)
    projPoint = _swig_property(_coin.SbViewVolume_projPoint_get, _coin.SbViewVolume_projPoint_set)
    projDir = _swig_property(_coin.SbViewVolume_projDir_get, _coin.SbViewVolume_projDir_set)
    nearDist = _swig_property(_coin.SbViewVolume_nearDist_get, _coin.SbViewVolume_nearDist_set)
    nearToFar = _swig_property(_coin.SbViewVolume_nearToFar_get, _coin.SbViewVolume_nearToFar_set)
    llf = _swig_property(_coin.SbViewVolume_llf_get, _coin.SbViewVolume_llf_set)
    lrf = _swig_property(_coin.SbViewVolume_lrf_get, _coin.SbViewVolume_lrf_set)
    ulf = _swig_property(_coin.SbViewVolume_ulf_get, _coin.SbViewVolume_ulf_set)
    def projectPointToLine(self, *args):
        """projectPointToLine(SbVec3f) -> (SbVec3f, SbVec3f)"""
        return _coin.SbViewVolume_projectPointToLine(self, *args)

    def projectToScreen(self, *args):
        """projectToScreen(SbVec3f) -> SbVec3f"""
        return _coin.SbViewVolume_projectToScreen(self, *args)

SbViewVolume_swigregister = _coin.SbViewVolume_swigregister
SbViewVolume_swigregister(SbViewVolume)

class SoSFVec3f(SoSField):
    """Proxy of C++ SoSFVec3f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFVec3f"""
        this = _coin.new_SoSFVec3f()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFVec3f
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFVec3f_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFVec3f_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFVec3f_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFVec3f_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFVec3f_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SbVec3f"""
        return _coin.SoSFVec3f_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFVec3f field) -> int"""
        return _coin.SoSFVec3f___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFVec3f field) -> int"""
        return _coin.SoSFVec3f___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFVec3f_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbVec3f newvalue)
        setValue(self, float x, float y, float z)
        setValue(self, float xyz)
        setValue(self, SoSFVec3f other)
        """
        return _coin.SoSFVec3f_setValue(self, *args)

SoSFVec3f_swigregister = _coin.SoSFVec3f_swigregister
SoSFVec3f_swigregister(SoSFVec3f)

def SoSFVec3f_createInstance():
  """SoSFVec3f_createInstance() -> void"""
  return _coin.SoSFVec3f_createInstance()

def SoSFVec3f_getClassTypeId():
  """SoSFVec3f_getClassTypeId() -> SoType"""
  return _coin.SoSFVec3f_getClassTypeId()

def SoSFVec3f_initClass():
  """SoSFVec3f_initClass()"""
  return _coin.SoSFVec3f_initClass()

class SoScale(SoTransformation):
    """Proxy of C++ SoScale class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoScale_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoScale_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoScale_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoScale"""
        this = _coin.new_SoScale()
        try: self.this.append(this)
        except: self.this = this
    scaleFactor = _swig_property(_coin.SoScale_scaleFactor_get, _coin.SoScale_scaleFactor_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoScale_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoScale_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoScale_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoScale_getBoundingBox(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoScale_getMatrix(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoScale_pick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoScale_getPrimitiveCount(self, *args)

SoScale_swigregister = _coin.SoScale_swigregister
SoScale_swigregister(SoScale)

def SoScale_getClassTypeId():
  """SoScale_getClassTypeId() -> SoType"""
  return _coin.SoScale_getClassTypeId()

def SoScale_initClass():
  """SoScale_initClass()"""
  return _coin.SoScale_initClass()

class SoDragger(SoInteractionKit):
    """Proxy of C++ SoDragger class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoDragger_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoDragger_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoDragger_getNodekitCatalog(self)

    isActive = _swig_property(_coin.SoDragger_isActive_get, _coin.SoDragger_isActive_set)
    FRONT = _coin.SoDragger_FRONT
    BACK = _coin.SoDragger_BACK
    USE_PICK = _coin.SoDragger_USE_PICK
    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoDragger_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoDragger_GLRender(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoDragger_getMatrix(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoDragger_rayPick(self, *args)

    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoDragger_search(self, *args)

    def write(self, *args):
        """write(self, SoWriteAction action)"""
        return _coin.SoDragger_write(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoDragger_getPrimitiveCount(self, *args)

    def setProjectorEpsilon(self, *args):
        """setProjectorEpsilon(self, float epsilon)"""
        return _coin.SoDragger_setProjectorEpsilon(self, *args)

    def getProjectorEpsilon(self):
        """getProjectorEpsilon(self) -> float"""
        return _coin.SoDragger_getProjectorEpsilon(self)

    def setMinGesture(self, *args):
        """setMinGesture(self, int pixels)"""
        return _coin.SoDragger_setMinGesture(self, *args)

    def getMinGesture(self):
        """getMinGesture(self) -> int"""
        return _coin.SoDragger_getMinGesture(self)

    def enableValueChangedCallbacks(self, *args):
        """enableValueChangedCallbacks(self, SbBool newval) -> SbBool"""
        return _coin.SoDragger_enableValueChangedCallbacks(self, *args)

    def getMotionMatrix(self):
        """getMotionMatrix(self) -> SbMatrix"""
        return _coin.SoDragger_getMotionMatrix(self)

    def registerChildDragger(self, *args):
        """registerChildDragger(self, SoDragger child)"""
        return _coin.SoDragger_registerChildDragger(self, *args)

    def unregisterChildDragger(self, *args):
        """unregisterChildDragger(self, SoDragger child)"""
        return _coin.SoDragger_unregisterChildDragger(self, *args)

    def registerChildDraggerMovingIndependently(self, *args):
        """registerChildDraggerMovingIndependently(self, SoDragger child)"""
        return _coin.SoDragger_registerChildDraggerMovingIndependently(self, *args)

    def unregisterChildDraggerMovingIndependently(self, *args):
        """unregisterChildDraggerMovingIndependently(self, SoDragger child)"""
        return _coin.SoDragger_unregisterChildDraggerMovingIndependently(self, *args)

    def getLocalToWorldMatrix(self):
        """getLocalToWorldMatrix(self) -> SbMatrix"""
        return _coin.SoDragger_getLocalToWorldMatrix(self)

    def getWorldToLocalMatrix(self):
        """getWorldToLocalMatrix(self) -> SbMatrix"""
        return _coin.SoDragger_getWorldToLocalMatrix(self)

    def getLocalStartingPoint(self):
        """getLocalStartingPoint(self) -> SbVec3f"""
        return _coin.SoDragger_getLocalStartingPoint(self)

    def getWorldStartingPoint(self):
        """getWorldStartingPoint(self) -> SbVec3f"""
        return _coin.SoDragger_getWorldStartingPoint(self)

    def getPartToLocalMatrix(self, *args):
        """getPartToLocalMatrix(self, SbName partname, SbMatrix parttolocalmatrix, SbMatrix localtopartmatrix)"""
        return _coin.SoDragger_getPartToLocalMatrix(self, *args)

    def transformMatrixLocalToWorld(self, *args):
        """transformMatrixLocalToWorld(self, SbMatrix frommatrix, SbMatrix tomatrix)"""
        return _coin.SoDragger_transformMatrixLocalToWorld(self, *args)

    def transformMatrixWorldToLocal(self, *args):
        """transformMatrixWorldToLocal(self, SbMatrix frommatrix, SbMatrix tomatrix)"""
        return _coin.SoDragger_transformMatrixWorldToLocal(self, *args)

    def transformMatrixToLocalSpace(self, *args):
        """transformMatrixToLocalSpace(self, SbMatrix frommatrix, SbMatrix tomatrix, SbName fromspacepartname)"""
        return _coin.SoDragger_transformMatrixToLocalSpace(self, *args)

    def setMotionMatrix(self, *args):
        """setMotionMatrix(self, SbMatrix newmatrix)"""
        return _coin.SoDragger_setMotionMatrix(self, *args)

    def valueChanged(self):
        """valueChanged(self)"""
        return _coin.SoDragger_valueChanged(self)

    def getStartMotionMatrix(self):
        """getStartMotionMatrix(self) -> SbMatrix"""
        return _coin.SoDragger_getStartMotionMatrix(self)

    def saveStartParameters(self):
        """saveStartParameters(self)"""
        return _coin.SoDragger_saveStartParameters(self)

    def getPickPath(self):
        """getPickPath(self) -> SoPath"""
        return _coin.SoDragger_getPickPath(self)

    def getEvent(self):
        """getEvent(self) -> SoEvent"""
        return _coin.SoDragger_getEvent(self)

    def createPathToThis(self):
        """createPathToThis(self) -> SoPath"""
        return _coin.SoDragger_createPathToThis(self)

    def getSurrogatePartPickedOwner(self):
        """getSurrogatePartPickedOwner(self) -> SoPath"""
        return _coin.SoDragger_getSurrogatePartPickedOwner(self)

    def getSurrogatePartPickedName(self):
        """getSurrogatePartPickedName(self) -> SbName"""
        return _coin.SoDragger_getSurrogatePartPickedName(self)

    def getSurrogatePartPickedPath(self):
        """getSurrogatePartPickedPath(self) -> SoPath"""
        return _coin.SoDragger_getSurrogatePartPickedPath(self)

    def setStartingPoint(self, *args):
        """
        setStartingPoint(self, SoPickedPoint newpoint)
        setStartingPoint(self, SbVec3f newpoint)
        """
        return _coin.SoDragger_setStartingPoint(self, *args)

    def getViewVolume(self):
        """getViewVolume(self) -> SbViewVolume"""
        return _coin.SoDragger_getViewVolume(self)

    def setViewVolume(self, *args):
        """setViewVolume(self, SbViewVolume vol)"""
        return _coin.SoDragger_setViewVolume(self, *args)

    def getViewportRegion(self):
        """getViewportRegion(self) -> SbViewportRegion"""
        return _coin.SoDragger_getViewportRegion(self)

    def setViewportRegion(self, *args):
        """setViewportRegion(self, SbViewportRegion reg)"""
        return _coin.SoDragger_setViewportRegion(self, *args)

    def getHandleEventAction(self):
        """getHandleEventAction(self) -> SoHandleEventAction"""
        return _coin.SoDragger_getHandleEventAction(self)

    def setHandleEventAction(self, *args):
        """setHandleEventAction(self, SoHandleEventAction newAction)"""
        return _coin.SoDragger_setHandleEventAction(self, *args)

    def setTempPathToThis(self, *args):
        """setTempPathToThis(self, SoPath somethingclose)"""
        return _coin.SoDragger_setTempPathToThis(self, *args)

    def grabEventsSetup(self):
        """grabEventsSetup(self)"""
        return _coin.SoDragger_grabEventsSetup(self)

    def grabEventsCleanup(self):
        """grabEventsCleanup(self)"""
        return _coin.SoDragger_grabEventsCleanup(self)

    def workFieldsIntoTransform(self, *args):
        """workFieldsIntoTransform(self, SbMatrix mtx)"""
        return _coin.SoDragger_workFieldsIntoTransform(self, *args)

    def setFrontOnProjector(self, *args):
        """setFrontOnProjector(self, ProjectorFrontSetting newval)"""
        return _coin.SoDragger_setFrontOnProjector(self, *args)

    def getFrontOnProjector(self):
        """getFrontOnProjector(self) -> ProjectorFrontSetting"""
        return _coin.SoDragger_getFrontOnProjector(self)

    def setMinScale(*args):
        """setMinScale(float newminscale)"""
        return _coin.SoDragger_setMinScale(*args)

    setMinScale = staticmethod(setMinScale)
    def getMinScale():
        """getMinScale() -> float"""
        return _coin.SoDragger_getMinScale()

    getMinScale = staticmethod(getMinScale)
    def workValuesIntoTransform(*args):
        """
        workValuesIntoTransform(SbMatrix mtx, SbVec3f translationptr, SbRotation rotationptr, 
            SbVec3f scalefactorptr, SbRotation scaleorientationptr, 
            SbVec3f centerptr)
        """
        return _coin.SoDragger_workValuesIntoTransform(*args)

    workValuesIntoTransform = staticmethod(workValuesIntoTransform)
    def getTransformFast(*args):
        """
        getTransformFast(SbMatrix mtx, SbVec3f translation, SbRotation rotation, 
            SbVec3f scalefactor, SbRotation scaleorientation, 
            SbVec3f center)
        getTransformFast(SbMatrix mtx, SbVec3f translation, SbRotation rotation, 
            SbVec3f scalefactor, SbRotation scaleorientation)
        """
        return _coin.SoDragger_getTransformFast(*args)

    getTransformFast = staticmethod(getTransformFast)
    def appendTranslation(*args):
        """
        appendTranslation(SbMatrix mtx, SbVec3f translation, SbMatrix conversion = None) -> SbMatrix
        appendTranslation(SbMatrix mtx, SbVec3f translation) -> SbMatrix
        """
        return _coin.SoDragger_appendTranslation(*args)

    appendTranslation = staticmethod(appendTranslation)
    def appendScale(*args):
        """
        appendScale(SbMatrix mtx, SbVec3f scale, SbVec3f scalecenter, SbMatrix conversion = None) -> SbMatrix
        appendScale(SbMatrix mtx, SbVec3f scale, SbVec3f scalecenter) -> SbMatrix
        """
        return _coin.SoDragger_appendScale(*args)

    appendScale = staticmethod(appendScale)
    def appendRotation(*args):
        """
        appendRotation(SbMatrix mtx, SbRotation rot, SbVec3f rotcenter, SbMatrix conversion = None) -> SbMatrix
        appendRotation(SbMatrix mtx, SbRotation rot, SbVec3f rotcenter) -> SbMatrix
        """
        return _coin.SoDragger_appendRotation(*args)

    appendRotation = staticmethod(appendRotation)
    def initClass():
        """initClass()"""
        return _coin.SoDragger_initClass()

    initClass = staticmethod(initClass)
    def initClasses():
        """initClasses()"""
        return _coin.SoDragger_initClasses()

    initClasses = staticmethod(initClasses)
    def addStartCallback(self, *args):
        """
        addStartCallback(self, SoDraggerCB func, void data = None)
        addStartCallback(self, SoDraggerCB func)
        addStartCallback(self, PyObject pyfunc, PyObject data = None)
        addStartCallback(self, PyObject pyfunc)
        """
        return _coin.SoDragger_addStartCallback(self, *args)

    def removeStartCallback(self, *args):
        """
        removeStartCallback(self, SoDraggerCB func, void data = None)
        removeStartCallback(self, SoDraggerCB func)
        removeStartCallback(self, PyObject pyfunc, PyObject data = None)
        removeStartCallback(self, PyObject pyfunc)
        """
        return _coin.SoDragger_removeStartCallback(self, *args)

    def addMotionCallback(self, *args):
        """
        addMotionCallback(self, SoDraggerCB func, void data = None)
        addMotionCallback(self, SoDraggerCB func)
        addMotionCallback(self, PyObject pyfunc, PyObject data = None)
        addMotionCallback(self, PyObject pyfunc)
        """
        return _coin.SoDragger_addMotionCallback(self, *args)

    def removeMotionCallback(self, *args):
        """
        removeMotionCallback(self, SoDraggerCB func, void data = None)
        removeMotionCallback(self, SoDraggerCB func)
        removeMotionCallback(self, PyObject pyfunc, PyObject data = None)
        removeMotionCallback(self, PyObject pyfunc)
        """
        return _coin.SoDragger_removeMotionCallback(self, *args)

    def addFinishCallback(self, *args):
        """
        addFinishCallback(self, SoDraggerCB func, void data = None)
        addFinishCallback(self, SoDraggerCB func)
        addFinishCallback(self, PyObject pyfunc, PyObject data = None)
        addFinishCallback(self, PyObject pyfunc)
        """
        return _coin.SoDragger_addFinishCallback(self, *args)

    def removeFinishCallback(self, *args):
        """
        removeFinishCallback(self, SoDraggerCB func, void data = None)
        removeFinishCallback(self, SoDraggerCB func)
        removeFinishCallback(self, PyObject pyfunc, PyObject data = None)
        removeFinishCallback(self, PyObject pyfunc)
        """
        return _coin.SoDragger_removeFinishCallback(self, *args)

    def addValueChangedCallback(self, *args):
        """
        addValueChangedCallback(self, SoDraggerCB func, void data = None)
        addValueChangedCallback(self, SoDraggerCB func)
        addValueChangedCallback(self, PyObject pyfunc, PyObject data = None)
        addValueChangedCallback(self, PyObject pyfunc)
        """
        return _coin.SoDragger_addValueChangedCallback(self, *args)

    def removeValueChangedCallback(self, *args):
        """
        removeValueChangedCallback(self, SoDraggerCB func, void data = None)
        removeValueChangedCallback(self, SoDraggerCB func)
        removeValueChangedCallback(self, PyObject pyfunc, PyObject data = None)
        removeValueChangedCallback(self, PyObject pyfunc)
        """
        return _coin.SoDragger_removeValueChangedCallback(self, *args)

    def addOtherEventCallback(self, *args):
        """
        addOtherEventCallback(self, SoDraggerCB func, void data = None)
        addOtherEventCallback(self, SoDraggerCB func)
        addOtherEventCallback(self, PyObject pyfunc, PyObject data = None)
        addOtherEventCallback(self, PyObject pyfunc)
        """
        return _coin.SoDragger_addOtherEventCallback(self, *args)

    def removeOtherEventCallback(self, *args):
        """
        removeOtherEventCallback(self, SoDraggerCB func, void data = None)
        removeOtherEventCallback(self, SoDraggerCB func)
        removeOtherEventCallback(self, PyObject pyfunc, PyObject data = None)
        removeOtherEventCallback(self, PyObject pyfunc)
        """
        return _coin.SoDragger_removeOtherEventCallback(self, *args)

SoDragger_swigregister = _coin.SoDragger_swigregister
SoDragger_swigregister(SoDragger)

def SoDragger_getClassTypeId():
  """SoDragger_getClassTypeId() -> SoType"""
  return _coin.SoDragger_getClassTypeId()

def SoDragger_getClassNodekitCatalog():
  """SoDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoDragger_getClassNodekitCatalog()

def SoDragger_setMinScale(*args):
  """SoDragger_setMinScale(float newminscale)"""
  return _coin.SoDragger_setMinScale(*args)

def SoDragger_getMinScale():
  """SoDragger_getMinScale() -> float"""
  return _coin.SoDragger_getMinScale()

def SoDragger_workValuesIntoTransform(*args):
  """
    SoDragger_workValuesIntoTransform(SbMatrix mtx, SbVec3f translationptr, SbRotation rotationptr, 
        SbVec3f scalefactorptr, SbRotation scaleorientationptr, 
        SbVec3f centerptr)
    """
  return _coin.SoDragger_workValuesIntoTransform(*args)

def SoDragger_getTransformFast(*args):
  """
    getTransformFast(SbMatrix mtx, SbVec3f translation, SbRotation rotation, 
        SbVec3f scalefactor, SbRotation scaleorientation, 
        SbVec3f center)
    SoDragger_getTransformFast(SbMatrix mtx, SbVec3f translation, SbRotation rotation, 
        SbVec3f scalefactor, SbRotation scaleorientation)
    """
  return _coin.SoDragger_getTransformFast(*args)

def SoDragger_appendTranslation(*args):
  """
    appendTranslation(SbMatrix mtx, SbVec3f translation, SbMatrix conversion = None) -> SbMatrix
    SoDragger_appendTranslation(SbMatrix mtx, SbVec3f translation) -> SbMatrix
    """
  return _coin.SoDragger_appendTranslation(*args)

def SoDragger_appendScale(*args):
  """
    appendScale(SbMatrix mtx, SbVec3f scale, SbVec3f scalecenter, SbMatrix conversion = None) -> SbMatrix
    SoDragger_appendScale(SbMatrix mtx, SbVec3f scale, SbVec3f scalecenter) -> SbMatrix
    """
  return _coin.SoDragger_appendScale(*args)

def SoDragger_appendRotation(*args):
  """
    appendRotation(SbMatrix mtx, SbRotation rot, SbVec3f rotcenter, SbMatrix conversion = None) -> SbMatrix
    SoDragger_appendRotation(SbMatrix mtx, SbRotation rot, SbVec3f rotcenter) -> SbMatrix
    """
  return _coin.SoDragger_appendRotation(*args)

def SoDragger_initClass():
  """SoDragger_initClass()"""
  return _coin.SoDragger_initClass()

def SoDragger_initClasses():
  """SoDragger_initClasses()"""
  return _coin.SoDragger_initClasses()

class SoSFRotation(SoSField):
    """Proxy of C++ SoSFRotation class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFRotation"""
        this = _coin.new_SoSFRotation()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFRotation
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFRotation_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFRotation_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFRotation_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFRotation_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFRotation_isSame(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoSFRotation field) -> int"""
        return _coin.SoSFRotation___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFRotation field) -> int"""
        return _coin.SoSFRotation___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFRotation_initClass()

    initClass = staticmethod(initClass)
    def getValue(self, *args):
        """
        getValue(self) -> SbRotation
        getValue(self, float angle)
        """
        return _coin.SoSFRotation_getValue(self, *args)

    def setValue(self, *args):
        """
        setValue(self, SbRotation newvalue)
        setValue(self, float q0, float q1, float q2, float q3)
        setValue(self, float q)
        setValue(self, SbVec3f axis, float angle)
        setValue(self, SoSFRotation other)
        """
        return _coin.SoSFRotation_setValue(self, *args)

SoSFRotation_swigregister = _coin.SoSFRotation_swigregister
SoSFRotation_swigregister(SoSFRotation)

def SoSFRotation_createInstance():
  """SoSFRotation_createInstance() -> void"""
  return _coin.SoSFRotation_createInstance()

def SoSFRotation_getClassTypeId():
  """SoSFRotation_getClassTypeId() -> SoType"""
  return _coin.SoSFRotation_getClassTypeId()

def SoSFRotation_initClass():
  """SoSFRotation_initClass()"""
  return _coin.SoSFRotation_initClass()

class SoCenterballDragger(SoDragger):
    """Proxy of C++ SoCenterballDragger class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoCenterballDragger_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoCenterballDragger_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoCenterballDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoCenterballDragger_getNodekitCatalog(self)

    def initClass():
        """initClass()"""
        return _coin.SoCenterballDragger_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoCenterballDragger"""
        this = _coin.new_SoCenterballDragger()
        try: self.this.append(this)
        except: self.this = this
    def saveStartParameters(self):
        """saveStartParameters(self)"""
        return _coin.SoCenterballDragger_saveStartParameters(self)

    rotation = _swig_property(_coin.SoCenterballDragger_rotation_get, _coin.SoCenterballDragger_rotation_set)
    center = _swig_property(_coin.SoCenterballDragger_center_get, _coin.SoCenterballDragger_center_set)
SoCenterballDragger_swigregister = _coin.SoCenterballDragger_swigregister
SoCenterballDragger_swigregister(SoCenterballDragger)

def SoCenterballDragger_getClassTypeId():
  """SoCenterballDragger_getClassTypeId() -> SoType"""
  return _coin.SoCenterballDragger_getClassTypeId()

def SoCenterballDragger_getClassNodekitCatalog():
  """SoCenterballDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoCenterballDragger_getClassNodekitCatalog()

def SoCenterballDragger_initClass():
  """SoCenterballDragger_initClass()"""
  return _coin.SoCenterballDragger_initClass()

class SoDirectionalLightDragger(SoDragger):
    """Proxy of C++ SoDirectionalLightDragger class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoDirectionalLightDragger_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoDirectionalLightDragger_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoDirectionalLightDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoDirectionalLightDragger_getNodekitCatalog(self)

    def initClass():
        """initClass()"""
        return _coin.SoDirectionalLightDragger_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoDirectionalLightDragger"""
        this = _coin.new_SoDirectionalLightDragger()
        try: self.this.append(this)
        except: self.this = this
    rotation = _swig_property(_coin.SoDirectionalLightDragger_rotation_get, _coin.SoDirectionalLightDragger_rotation_set)
    translation = _swig_property(_coin.SoDirectionalLightDragger_translation_get, _coin.SoDirectionalLightDragger_translation_set)
SoDirectionalLightDragger_swigregister = _coin.SoDirectionalLightDragger_swigregister
SoDirectionalLightDragger_swigregister(SoDirectionalLightDragger)

def SoDirectionalLightDragger_getClassTypeId():
  """SoDirectionalLightDragger_getClassTypeId() -> SoType"""
  return _coin.SoDirectionalLightDragger_getClassTypeId()

def SoDirectionalLightDragger_getClassNodekitCatalog():
  """SoDirectionalLightDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoDirectionalLightDragger_getClassNodekitCatalog()

def SoDirectionalLightDragger_initClass():
  """SoDirectionalLightDragger_initClass()"""
  return _coin.SoDirectionalLightDragger_initClass()

class SoDragPointDragger(SoDragger):
    """Proxy of C++ SoDragPointDragger class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoDragPointDragger_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoDragPointDragger_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoDragPointDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoDragPointDragger_getNodekitCatalog(self)

    def initClass():
        """initClass()"""
        return _coin.SoDragPointDragger_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoDragPointDragger"""
        this = _coin.new_SoDragPointDragger()
        try: self.this.append(this)
        except: self.this = this
    translation = _swig_property(_coin.SoDragPointDragger_translation_get, _coin.SoDragPointDragger_translation_set)
    def setJumpLimit(self, *args):
        """setJumpLimit(self, float limit)"""
        return _coin.SoDragPointDragger_setJumpLimit(self, *args)

    def getJumpLimit(self):
        """getJumpLimit(self) -> float"""
        return _coin.SoDragPointDragger_getJumpLimit(self)

    def showNextDraggerSet(self):
        """showNextDraggerSet(self)"""
        return _coin.SoDragPointDragger_showNextDraggerSet(self)

SoDragPointDragger_swigregister = _coin.SoDragPointDragger_swigregister
SoDragPointDragger_swigregister(SoDragPointDragger)

def SoDragPointDragger_getClassTypeId():
  """SoDragPointDragger_getClassTypeId() -> SoType"""
  return _coin.SoDragPointDragger_getClassTypeId()

def SoDragPointDragger_getClassNodekitCatalog():
  """SoDragPointDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoDragPointDragger_getClassNodekitCatalog()

def SoDragPointDragger_initClass():
  """SoDragPointDragger_initClass()"""
  return _coin.SoDragPointDragger_initClass()

class SoHandleBoxDragger(SoDragger):
    """Proxy of C++ SoHandleBoxDragger class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoHandleBoxDragger_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoHandleBoxDragger_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoHandleBoxDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoHandleBoxDragger_getNodekitCatalog(self)

    def initClass():
        """initClass()"""
        return _coin.SoHandleBoxDragger_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoHandleBoxDragger"""
        this = _coin.new_SoHandleBoxDragger()
        try: self.this.append(this)
        except: self.this = this
    scaleFactor = _swig_property(_coin.SoHandleBoxDragger_scaleFactor_get, _coin.SoHandleBoxDragger_scaleFactor_set)
    translation = _swig_property(_coin.SoHandleBoxDragger_translation_get, _coin.SoHandleBoxDragger_translation_set)
SoHandleBoxDragger_swigregister = _coin.SoHandleBoxDragger_swigregister
SoHandleBoxDragger_swigregister(SoHandleBoxDragger)

def SoHandleBoxDragger_getClassTypeId():
  """SoHandleBoxDragger_getClassTypeId() -> SoType"""
  return _coin.SoHandleBoxDragger_getClassTypeId()

def SoHandleBoxDragger_getClassNodekitCatalog():
  """SoHandleBoxDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoHandleBoxDragger_getClassNodekitCatalog()

def SoHandleBoxDragger_initClass():
  """SoHandleBoxDragger_initClass()"""
  return _coin.SoHandleBoxDragger_initClass()

class SoJackDragger(SoDragger):
    """Proxy of C++ SoJackDragger class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoJackDragger_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoJackDragger_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoJackDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoJackDragger_getNodekitCatalog(self)

    def initClass():
        """initClass()"""
        return _coin.SoJackDragger_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoJackDragger"""
        this = _coin.new_SoJackDragger()
        try: self.this.append(this)
        except: self.this = this
    rotation = _swig_property(_coin.SoJackDragger_rotation_get, _coin.SoJackDragger_rotation_set)
    translation = _swig_property(_coin.SoJackDragger_translation_get, _coin.SoJackDragger_translation_set)
    scaleFactor = _swig_property(_coin.SoJackDragger_scaleFactor_get, _coin.SoJackDragger_scaleFactor_set)
SoJackDragger_swigregister = _coin.SoJackDragger_swigregister
SoJackDragger_swigregister(SoJackDragger)

def SoJackDragger_getClassTypeId():
  """SoJackDragger_getClassTypeId() -> SoType"""
  return _coin.SoJackDragger_getClassTypeId()

def SoJackDragger_getClassNodekitCatalog():
  """SoJackDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoJackDragger_getClassNodekitCatalog()

def SoJackDragger_initClass():
  """SoJackDragger_initClass()"""
  return _coin.SoJackDragger_initClass()

class SoPointLightDragger(SoDragger):
    """Proxy of C++ SoPointLightDragger class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoPointLightDragger_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoPointLightDragger_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoPointLightDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoPointLightDragger_getNodekitCatalog(self)

    def initClass():
        """initClass()"""
        return _coin.SoPointLightDragger_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoPointLightDragger"""
        this = _coin.new_SoPointLightDragger()
        try: self.this.append(this)
        except: self.this = this
    translation = _swig_property(_coin.SoPointLightDragger_translation_get, _coin.SoPointLightDragger_translation_set)
SoPointLightDragger_swigregister = _coin.SoPointLightDragger_swigregister
SoPointLightDragger_swigregister(SoPointLightDragger)

def SoPointLightDragger_getClassTypeId():
  """SoPointLightDragger_getClassTypeId() -> SoType"""
  return _coin.SoPointLightDragger_getClassTypeId()

def SoPointLightDragger_getClassNodekitCatalog():
  """SoPointLightDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoPointLightDragger_getClassNodekitCatalog()

def SoPointLightDragger_initClass():
  """SoPointLightDragger_initClass()"""
  return _coin.SoPointLightDragger_initClass()

class SoRotateCylindricalDragger(SoDragger):
    """Proxy of C++ SoRotateCylindricalDragger class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoRotateCylindricalDragger_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoRotateCylindricalDragger_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoRotateCylindricalDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoRotateCylindricalDragger_getNodekitCatalog(self)

    def initClass():
        """initClass()"""
        return _coin.SoRotateCylindricalDragger_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoRotateCylindricalDragger"""
        this = _coin.new_SoRotateCylindricalDragger()
        try: self.this.append(this)
        except: self.this = this
    rotation = _swig_property(_coin.SoRotateCylindricalDragger_rotation_get, _coin.SoRotateCylindricalDragger_rotation_set)
    def setProjector(self, *args):
        """setProjector(self, SbCylinderProjector p)"""
        return _coin.SoRotateCylindricalDragger_setProjector(self, *args)

    def getProjector(self):
        """getProjector(self) -> SbCylinderProjector"""
        return _coin.SoRotateCylindricalDragger_getProjector(self)

SoRotateCylindricalDragger_swigregister = _coin.SoRotateCylindricalDragger_swigregister
SoRotateCylindricalDragger_swigregister(SoRotateCylindricalDragger)

def SoRotateCylindricalDragger_getClassTypeId():
  """SoRotateCylindricalDragger_getClassTypeId() -> SoType"""
  return _coin.SoRotateCylindricalDragger_getClassTypeId()

def SoRotateCylindricalDragger_getClassNodekitCatalog():
  """SoRotateCylindricalDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoRotateCylindricalDragger_getClassNodekitCatalog()

def SoRotateCylindricalDragger_initClass():
  """SoRotateCylindricalDragger_initClass()"""
  return _coin.SoRotateCylindricalDragger_initClass()

class SoRotateDiscDragger(SoDragger):
    """Proxy of C++ SoRotateDiscDragger class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoRotateDiscDragger_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoRotateDiscDragger_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoRotateDiscDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoRotateDiscDragger_getNodekitCatalog(self)

    def initClass():
        """initClass()"""
        return _coin.SoRotateDiscDragger_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoRotateDiscDragger"""
        this = _coin.new_SoRotateDiscDragger()
        try: self.this.append(this)
        except: self.this = this
    rotation = _swig_property(_coin.SoRotateDiscDragger_rotation_get, _coin.SoRotateDiscDragger_rotation_set)
SoRotateDiscDragger_swigregister = _coin.SoRotateDiscDragger_swigregister
SoRotateDiscDragger_swigregister(SoRotateDiscDragger)

def SoRotateDiscDragger_getClassTypeId():
  """SoRotateDiscDragger_getClassTypeId() -> SoType"""
  return _coin.SoRotateDiscDragger_getClassTypeId()

def SoRotateDiscDragger_getClassNodekitCatalog():
  """SoRotateDiscDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoRotateDiscDragger_getClassNodekitCatalog()

def SoRotateDiscDragger_initClass():
  """SoRotateDiscDragger_initClass()"""
  return _coin.SoRotateDiscDragger_initClass()

class SoRotateSphericalDragger(SoDragger):
    """Proxy of C++ SoRotateSphericalDragger class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoRotateSphericalDragger_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoRotateSphericalDragger_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoRotateSphericalDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoRotateSphericalDragger_getNodekitCatalog(self)

    def initClass():
        """initClass()"""
        return _coin.SoRotateSphericalDragger_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoRotateSphericalDragger"""
        this = _coin.new_SoRotateSphericalDragger()
        try: self.this.append(this)
        except: self.this = this
    rotation = _swig_property(_coin.SoRotateSphericalDragger_rotation_get, _coin.SoRotateSphericalDragger_rotation_set)
    def setProjector(self, *args):
        """setProjector(self, SbSphereProjector p)"""
        return _coin.SoRotateSphericalDragger_setProjector(self, *args)

    def getProjector(self):
        """getProjector(self) -> SbSphereProjector"""
        return _coin.SoRotateSphericalDragger_getProjector(self)

SoRotateSphericalDragger_swigregister = _coin.SoRotateSphericalDragger_swigregister
SoRotateSphericalDragger_swigregister(SoRotateSphericalDragger)

def SoRotateSphericalDragger_getClassTypeId():
  """SoRotateSphericalDragger_getClassTypeId() -> SoType"""
  return _coin.SoRotateSphericalDragger_getClassTypeId()

def SoRotateSphericalDragger_getClassNodekitCatalog():
  """SoRotateSphericalDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoRotateSphericalDragger_getClassNodekitCatalog()

def SoRotateSphericalDragger_initClass():
  """SoRotateSphericalDragger_initClass()"""
  return _coin.SoRotateSphericalDragger_initClass()

class SoScale1Dragger(SoDragger):
    """Proxy of C++ SoScale1Dragger class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoScale1Dragger_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoScale1Dragger_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoScale1Dragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoScale1Dragger_getNodekitCatalog(self)

    def initClass():
        """initClass()"""
        return _coin.SoScale1Dragger_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoScale1Dragger"""
        this = _coin.new_SoScale1Dragger()
        try: self.this.append(this)
        except: self.this = this
    scaleFactor = _swig_property(_coin.SoScale1Dragger_scaleFactor_get, _coin.SoScale1Dragger_scaleFactor_set)
SoScale1Dragger_swigregister = _coin.SoScale1Dragger_swigregister
SoScale1Dragger_swigregister(SoScale1Dragger)

def SoScale1Dragger_getClassTypeId():
  """SoScale1Dragger_getClassTypeId() -> SoType"""
  return _coin.SoScale1Dragger_getClassTypeId()

def SoScale1Dragger_getClassNodekitCatalog():
  """SoScale1Dragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoScale1Dragger_getClassNodekitCatalog()

def SoScale1Dragger_initClass():
  """SoScale1Dragger_initClass()"""
  return _coin.SoScale1Dragger_initClass()

class SoScale2Dragger(SoDragger):
    """Proxy of C++ SoScale2Dragger class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoScale2Dragger_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoScale2Dragger_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoScale2Dragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoScale2Dragger_getNodekitCatalog(self)

    def initClass():
        """initClass()"""
        return _coin.SoScale2Dragger_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoScale2Dragger"""
        this = _coin.new_SoScale2Dragger()
        try: self.this.append(this)
        except: self.this = this
    scaleFactor = _swig_property(_coin.SoScale2Dragger_scaleFactor_get, _coin.SoScale2Dragger_scaleFactor_set)
SoScale2Dragger_swigregister = _coin.SoScale2Dragger_swigregister
SoScale2Dragger_swigregister(SoScale2Dragger)

def SoScale2Dragger_getClassTypeId():
  """SoScale2Dragger_getClassTypeId() -> SoType"""
  return _coin.SoScale2Dragger_getClassTypeId()

def SoScale2Dragger_getClassNodekitCatalog():
  """SoScale2Dragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoScale2Dragger_getClassNodekitCatalog()

def SoScale2Dragger_initClass():
  """SoScale2Dragger_initClass()"""
  return _coin.SoScale2Dragger_initClass()

class SoScale2UniformDragger(SoDragger):
    """Proxy of C++ SoScale2UniformDragger class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoScale2UniformDragger_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoScale2UniformDragger_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoScale2UniformDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoScale2UniformDragger_getNodekitCatalog(self)

    def initClass():
        """initClass()"""
        return _coin.SoScale2UniformDragger_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoScale2UniformDragger"""
        this = _coin.new_SoScale2UniformDragger()
        try: self.this.append(this)
        except: self.this = this
    scaleFactor = _swig_property(_coin.SoScale2UniformDragger_scaleFactor_get, _coin.SoScale2UniformDragger_scaleFactor_set)
SoScale2UniformDragger_swigregister = _coin.SoScale2UniformDragger_swigregister
SoScale2UniformDragger_swigregister(SoScale2UniformDragger)

def SoScale2UniformDragger_getClassTypeId():
  """SoScale2UniformDragger_getClassTypeId() -> SoType"""
  return _coin.SoScale2UniformDragger_getClassTypeId()

def SoScale2UniformDragger_getClassNodekitCatalog():
  """SoScale2UniformDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoScale2UniformDragger_getClassNodekitCatalog()

def SoScale2UniformDragger_initClass():
  """SoScale2UniformDragger_initClass()"""
  return _coin.SoScale2UniformDragger_initClass()

class SoScaleUniformDragger(SoDragger):
    """Proxy of C++ SoScaleUniformDragger class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoScaleUniformDragger_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoScaleUniformDragger_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoScaleUniformDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoScaleUniformDragger_getNodekitCatalog(self)

    def initClass():
        """initClass()"""
        return _coin.SoScaleUniformDragger_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoScaleUniformDragger"""
        this = _coin.new_SoScaleUniformDragger()
        try: self.this.append(this)
        except: self.this = this
    scaleFactor = _swig_property(_coin.SoScaleUniformDragger_scaleFactor_get, _coin.SoScaleUniformDragger_scaleFactor_set)
SoScaleUniformDragger_swigregister = _coin.SoScaleUniformDragger_swigregister
SoScaleUniformDragger_swigregister(SoScaleUniformDragger)

def SoScaleUniformDragger_getClassTypeId():
  """SoScaleUniformDragger_getClassTypeId() -> SoType"""
  return _coin.SoScaleUniformDragger_getClassTypeId()

def SoScaleUniformDragger_getClassNodekitCatalog():
  """SoScaleUniformDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoScaleUniformDragger_getClassNodekitCatalog()

def SoScaleUniformDragger_initClass():
  """SoScaleUniformDragger_initClass()"""
  return _coin.SoScaleUniformDragger_initClass()

class SoSpotLightDragger(SoDragger):
    """Proxy of C++ SoSpotLightDragger class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSpotLightDragger_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSpotLightDragger_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoSpotLightDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoSpotLightDragger_getNodekitCatalog(self)

    def initClass():
        """initClass()"""
        return _coin.SoSpotLightDragger_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoSpotLightDragger"""
        this = _coin.new_SoSpotLightDragger()
        try: self.this.append(this)
        except: self.this = this
    rotation = _swig_property(_coin.SoSpotLightDragger_rotation_get, _coin.SoSpotLightDragger_rotation_set)
    translation = _swig_property(_coin.SoSpotLightDragger_translation_get, _coin.SoSpotLightDragger_translation_set)
    angle = _swig_property(_coin.SoSpotLightDragger_angle_get, _coin.SoSpotLightDragger_angle_set)
SoSpotLightDragger_swigregister = _coin.SoSpotLightDragger_swigregister
SoSpotLightDragger_swigregister(SoSpotLightDragger)

def SoSpotLightDragger_getClassTypeId():
  """SoSpotLightDragger_getClassTypeId() -> SoType"""
  return _coin.SoSpotLightDragger_getClassTypeId()

def SoSpotLightDragger_getClassNodekitCatalog():
  """SoSpotLightDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoSpotLightDragger_getClassNodekitCatalog()

def SoSpotLightDragger_initClass():
  """SoSpotLightDragger_initClass()"""
  return _coin.SoSpotLightDragger_initClass()

class SoTabBoxDragger(SoDragger):
    """Proxy of C++ SoTabBoxDragger class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTabBoxDragger_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTabBoxDragger_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoTabBoxDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoTabBoxDragger_getNodekitCatalog(self)

    def initClass():
        """initClass()"""
        return _coin.SoTabBoxDragger_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTabBoxDragger"""
        this = _coin.new_SoTabBoxDragger()
        try: self.this.append(this)
        except: self.this = this
    translation = _swig_property(_coin.SoTabBoxDragger_translation_get, _coin.SoTabBoxDragger_translation_set)
    scaleFactor = _swig_property(_coin.SoTabBoxDragger_scaleFactor_get, _coin.SoTabBoxDragger_scaleFactor_set)
    def adjustScaleTabSize(self):
        """adjustScaleTabSize(self)"""
        return _coin.SoTabBoxDragger_adjustScaleTabSize(self)

SoTabBoxDragger_swigregister = _coin.SoTabBoxDragger_swigregister
SoTabBoxDragger_swigregister(SoTabBoxDragger)

def SoTabBoxDragger_getClassTypeId():
  """SoTabBoxDragger_getClassTypeId() -> SoType"""
  return _coin.SoTabBoxDragger_getClassTypeId()

def SoTabBoxDragger_getClassNodekitCatalog():
  """SoTabBoxDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoTabBoxDragger_getClassNodekitCatalog()

def SoTabBoxDragger_initClass():
  """SoTabBoxDragger_initClass()"""
  return _coin.SoTabBoxDragger_initClass()

class SoTabPlaneDragger(SoDragger):
    """Proxy of C++ SoTabPlaneDragger class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTabPlaneDragger_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTabPlaneDragger_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoTabPlaneDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoTabPlaneDragger_getNodekitCatalog(self)

    def initClass():
        """initClass()"""
        return _coin.SoTabPlaneDragger_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTabPlaneDragger"""
        this = _coin.new_SoTabPlaneDragger()
        try: self.this.append(this)
        except: self.this = this
    translation = _swig_property(_coin.SoTabPlaneDragger_translation_get, _coin.SoTabPlaneDragger_translation_set)
    scaleFactor = _swig_property(_coin.SoTabPlaneDragger_scaleFactor_get, _coin.SoTabPlaneDragger_scaleFactor_set)
    def adjustScaleTabSize(self):
        """adjustScaleTabSize(self)"""
        return _coin.SoTabPlaneDragger_adjustScaleTabSize(self)

SoTabPlaneDragger_swigregister = _coin.SoTabPlaneDragger_swigregister
SoTabPlaneDragger_swigregister(SoTabPlaneDragger)

def SoTabPlaneDragger_getClassTypeId():
  """SoTabPlaneDragger_getClassTypeId() -> SoType"""
  return _coin.SoTabPlaneDragger_getClassTypeId()

def SoTabPlaneDragger_getClassNodekitCatalog():
  """SoTabPlaneDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoTabPlaneDragger_getClassNodekitCatalog()

def SoTabPlaneDragger_initClass():
  """SoTabPlaneDragger_initClass()"""
  return _coin.SoTabPlaneDragger_initClass()

class SoTrackballDragger(SoDragger):
    """Proxy of C++ SoTrackballDragger class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTrackballDragger_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTrackballDragger_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoTrackballDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoTrackballDragger_getNodekitCatalog(self)

    def initClass():
        """initClass()"""
        return _coin.SoTrackballDragger_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTrackballDragger"""
        this = _coin.new_SoTrackballDragger()
        try: self.this.append(this)
        except: self.this = this
    rotation = _swig_property(_coin.SoTrackballDragger_rotation_get, _coin.SoTrackballDragger_rotation_set)
    scaleFactor = _swig_property(_coin.SoTrackballDragger_scaleFactor_get, _coin.SoTrackballDragger_scaleFactor_set)
    def isAnimationEnabled(self):
        """isAnimationEnabled(self) -> SbBool"""
        return _coin.SoTrackballDragger_isAnimationEnabled(self)

    def setAnimationEnabled(self, *args):
        """setAnimationEnabled(self, SbBool newval)"""
        return _coin.SoTrackballDragger_setAnimationEnabled(self, *args)

SoTrackballDragger_swigregister = _coin.SoTrackballDragger_swigregister
SoTrackballDragger_swigregister(SoTrackballDragger)

def SoTrackballDragger_getClassTypeId():
  """SoTrackballDragger_getClassTypeId() -> SoType"""
  return _coin.SoTrackballDragger_getClassTypeId()

def SoTrackballDragger_getClassNodekitCatalog():
  """SoTrackballDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoTrackballDragger_getClassNodekitCatalog()

def SoTrackballDragger_initClass():
  """SoTrackballDragger_initClass()"""
  return _coin.SoTrackballDragger_initClass()

class SoTransformBoxDragger(SoDragger):
    """Proxy of C++ SoTransformBoxDragger class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTransformBoxDragger_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTransformBoxDragger_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoTransformBoxDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoTransformBoxDragger_getNodekitCatalog(self)

    def initClass():
        """initClass()"""
        return _coin.SoTransformBoxDragger_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTransformBoxDragger"""
        this = _coin.new_SoTransformBoxDragger()
        try: self.this.append(this)
        except: self.this = this
    rotation = _swig_property(_coin.SoTransformBoxDragger_rotation_get, _coin.SoTransformBoxDragger_rotation_set)
    translation = _swig_property(_coin.SoTransformBoxDragger_translation_get, _coin.SoTransformBoxDragger_translation_set)
    scaleFactor = _swig_property(_coin.SoTransformBoxDragger_scaleFactor_get, _coin.SoTransformBoxDragger_scaleFactor_set)
SoTransformBoxDragger_swigregister = _coin.SoTransformBoxDragger_swigregister
SoTransformBoxDragger_swigregister(SoTransformBoxDragger)

def SoTransformBoxDragger_getClassTypeId():
  """SoTransformBoxDragger_getClassTypeId() -> SoType"""
  return _coin.SoTransformBoxDragger_getClassTypeId()

def SoTransformBoxDragger_getClassNodekitCatalog():
  """SoTransformBoxDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoTransformBoxDragger_getClassNodekitCatalog()

def SoTransformBoxDragger_initClass():
  """SoTransformBoxDragger_initClass()"""
  return _coin.SoTransformBoxDragger_initClass()

class SoTransformerDragger(SoDragger):
    """Proxy of C++ SoTransformerDragger class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTransformerDragger_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTransformerDragger_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoTransformerDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoTransformerDragger_getNodekitCatalog(self)

    def initClass():
        """initClass()"""
        return _coin.SoTransformerDragger_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTransformerDragger"""
        this = _coin.new_SoTransformerDragger()
        try: self.this.append(this)
        except: self.this = this
    rotation = _swig_property(_coin.SoTransformerDragger_rotation_get, _coin.SoTransformerDragger_rotation_set)
    translation = _swig_property(_coin.SoTransformerDragger_translation_get, _coin.SoTransformerDragger_translation_set)
    scaleFactor = _swig_property(_coin.SoTransformerDragger_scaleFactor_get, _coin.SoTransformerDragger_scaleFactor_set)
    minDiscRotDot = _swig_property(_coin.SoTransformerDragger_minDiscRotDot_get, _coin.SoTransformerDragger_minDiscRotDot_set)
    INACTIVE = _coin.SoTransformerDragger_INACTIVE
    RIT_X_ROTATE = _coin.SoTransformerDragger_RIT_X_ROTATE
    TOP_Y_ROTATE = _coin.SoTransformerDragger_TOP_Y_ROTATE
    FNT_Z_ROTATE = _coin.SoTransformerDragger_FNT_Z_ROTATE
    LFT_X_ROTATE = _coin.SoTransformerDragger_LFT_X_ROTATE
    BOT_Y_ROTATE = _coin.SoTransformerDragger_BOT_Y_ROTATE
    BAK_Z_ROTATE = _coin.SoTransformerDragger_BAK_Z_ROTATE
    PX_PY_PZ_3D_SCALE = _coin.SoTransformerDragger_PX_PY_PZ_3D_SCALE
    PX_PY_NZ_3D_SCALE = _coin.SoTransformerDragger_PX_PY_NZ_3D_SCALE
    PX_NY_PZ_3D_SCALE = _coin.SoTransformerDragger_PX_NY_PZ_3D_SCALE
    PX_NY_NZ_3D_SCALE = _coin.SoTransformerDragger_PX_NY_NZ_3D_SCALE
    NX_PY_PZ_3D_SCALE = _coin.SoTransformerDragger_NX_PY_PZ_3D_SCALE
    NX_PY_NZ_3D_SCALE = _coin.SoTransformerDragger_NX_PY_NZ_3D_SCALE
    NX_NY_PZ_3D_SCALE = _coin.SoTransformerDragger_NX_NY_PZ_3D_SCALE
    NX_NY_NZ_3D_SCALE = _coin.SoTransformerDragger_NX_NY_NZ_3D_SCALE
    RIT_TRANSLATE = _coin.SoTransformerDragger_RIT_TRANSLATE
    TOP_TRANSLATE = _coin.SoTransformerDragger_TOP_TRANSLATE
    FNT_TRANSLATE = _coin.SoTransformerDragger_FNT_TRANSLATE
    LFT_TRANSLATE = _coin.SoTransformerDragger_LFT_TRANSLATE
    BOT_TRANSLATE = _coin.SoTransformerDragger_BOT_TRANSLATE
    BAK_TRANSLATE = _coin.SoTransformerDragger_BAK_TRANSLATE
    def getCurrentState(self):
        """getCurrentState(self) -> State"""
        return _coin.SoTransformerDragger_getCurrentState(self)

    def unsquishKnobs(self):
        """unsquishKnobs(self)"""
        return _coin.SoTransformerDragger_unsquishKnobs(self)

    def isLocateHighlighting(self):
        """isLocateHighlighting(self) -> SbBool"""
        return _coin.SoTransformerDragger_isLocateHighlighting(self)

    def setLocateHighlighting(self, *args):
        """setLocateHighlighting(self, SbBool onoff)"""
        return _coin.SoTransformerDragger_setLocateHighlighting(self, *args)

    def setColinearThreshold(*args):
        """setColinearThreshold(int newval)"""
        return _coin.SoTransformerDragger_setColinearThreshold(*args)

    setColinearThreshold = staticmethod(setColinearThreshold)
    def getColinearThreshold():
        """getColinearThreshold() -> int"""
        return _coin.SoTransformerDragger_getColinearThreshold()

    getColinearThreshold = staticmethod(getColinearThreshold)
    def getBoxPointInWorldSpace(self, *args):
        """getBoxPointInWorldSpace(self, SbVec3f pointonunitbox) -> SbVec3f"""
        return _coin.SoTransformerDragger_getBoxPointInWorldSpace(self, *args)

    def getBoxDirInWorldSpace(self, *args):
        """getBoxDirInWorldSpace(self, SbVec3f dironunitbox) -> SbVec3f"""
        return _coin.SoTransformerDragger_getBoxDirInWorldSpace(self, *args)

    def getWorldPointInBoxSpace(self, *args):
        """getWorldPointInBoxSpace(self, SbVec3f pointinworldspace) -> SbVec3f"""
        return _coin.SoTransformerDragger_getWorldPointInBoxSpace(self, *args)

    def getWorldPointInPixelSpace(self, *args):
        """getWorldPointInPixelSpace(self, SbVec3f thepoint) -> SbVec2f"""
        return _coin.SoTransformerDragger_getWorldPointInPixelSpace(self, *args)

    def getInteractiveCenterInBoxSpace(self):
        """getInteractiveCenterInBoxSpace(self) -> SbVec3f"""
        return _coin.SoTransformerDragger_getInteractiveCenterInBoxSpace(self)

SoTransformerDragger_swigregister = _coin.SoTransformerDragger_swigregister
SoTransformerDragger_swigregister(SoTransformerDragger)

def SoTransformerDragger_getClassTypeId():
  """SoTransformerDragger_getClassTypeId() -> SoType"""
  return _coin.SoTransformerDragger_getClassTypeId()

def SoTransformerDragger_getClassNodekitCatalog():
  """SoTransformerDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoTransformerDragger_getClassNodekitCatalog()

def SoTransformerDragger_initClass():
  """SoTransformerDragger_initClass()"""
  return _coin.SoTransformerDragger_initClass()

def SoTransformerDragger_setColinearThreshold(*args):
  """SoTransformerDragger_setColinearThreshold(int newval)"""
  return _coin.SoTransformerDragger_setColinearThreshold(*args)

def SoTransformerDragger_getColinearThreshold():
  """SoTransformerDragger_getColinearThreshold() -> int"""
  return _coin.SoTransformerDragger_getColinearThreshold()

class SoTranslate1Dragger(SoDragger):
    """Proxy of C++ SoTranslate1Dragger class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTranslate1Dragger_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTranslate1Dragger_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoTranslate1Dragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoTranslate1Dragger_getNodekitCatalog(self)

    def initClass():
        """initClass()"""
        return _coin.SoTranslate1Dragger_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTranslate1Dragger"""
        this = _coin.new_SoTranslate1Dragger()
        try: self.this.append(this)
        except: self.this = this
    translation = _swig_property(_coin.SoTranslate1Dragger_translation_get, _coin.SoTranslate1Dragger_translation_set)
    minTranslation = _swig_property(_coin.SoTranslate1Dragger_minTranslation_get, _coin.SoTranslate1Dragger_minTranslation_set)
    maxTranslation = _swig_property(_coin.SoTranslate1Dragger_maxTranslation_get, _coin.SoTranslate1Dragger_maxTranslation_set)
SoTranslate1Dragger_swigregister = _coin.SoTranslate1Dragger_swigregister
SoTranslate1Dragger_swigregister(SoTranslate1Dragger)

def SoTranslate1Dragger_getClassTypeId():
  """SoTranslate1Dragger_getClassTypeId() -> SoType"""
  return _coin.SoTranslate1Dragger_getClassTypeId()

def SoTranslate1Dragger_getClassNodekitCatalog():
  """SoTranslate1Dragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoTranslate1Dragger_getClassNodekitCatalog()

def SoTranslate1Dragger_initClass():
  """SoTranslate1Dragger_initClass()"""
  return _coin.SoTranslate1Dragger_initClass()

class SoSFVec2f(SoSField):
    """Proxy of C++ SoSFVec2f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFVec2f"""
        this = _coin.new_SoSFVec2f()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFVec2f
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFVec2f_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFVec2f_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFVec2f_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFVec2f_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFVec2f_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SbVec2f"""
        return _coin.SoSFVec2f_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFVec2f field) -> int"""
        return _coin.SoSFVec2f___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFVec2f field) -> int"""
        return _coin.SoSFVec2f___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFVec2f_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbVec2f newvalue)
        setValue(self, float x, float y)
        setValue(self, float xy)
        setValue(self, SoSFVec2f other)
        """
        return _coin.SoSFVec2f_setValue(self, *args)

SoSFVec2f_swigregister = _coin.SoSFVec2f_swigregister
SoSFVec2f_swigregister(SoSFVec2f)

def SoSFVec2f_createInstance():
  """SoSFVec2f_createInstance() -> void"""
  return _coin.SoSFVec2f_createInstance()

def SoSFVec2f_getClassTypeId():
  """SoSFVec2f_getClassTypeId() -> SoType"""
  return _coin.SoSFVec2f_getClassTypeId()

def SoSFVec2f_initClass():
  """SoSFVec2f_initClass()"""
  return _coin.SoSFVec2f_initClass()

class SoTranslate2Dragger(SoDragger):
    """Proxy of C++ SoTranslate2Dragger class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTranslate2Dragger_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTranslate2Dragger_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoTranslate2Dragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoTranslate2Dragger_getNodekitCatalog(self)

    def initClass():
        """initClass()"""
        return _coin.SoTranslate2Dragger_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTranslate2Dragger"""
        this = _coin.new_SoTranslate2Dragger()
        try: self.this.append(this)
        except: self.this = this
    translation = _swig_property(_coin.SoTranslate2Dragger_translation_get, _coin.SoTranslate2Dragger_translation_set)
    minTranslation = _swig_property(_coin.SoTranslate2Dragger_minTranslation_get, _coin.SoTranslate2Dragger_minTranslation_set)
    maxTranslation = _swig_property(_coin.SoTranslate2Dragger_maxTranslation_get, _coin.SoTranslate2Dragger_maxTranslation_set)
SoTranslate2Dragger_swigregister = _coin.SoTranslate2Dragger_swigregister
SoTranslate2Dragger_swigregister(SoTranslate2Dragger)

def SoTranslate2Dragger_getClassTypeId():
  """SoTranslate2Dragger_getClassTypeId() -> SoType"""
  return _coin.SoTranslate2Dragger_getClassTypeId()

def SoTranslate2Dragger_getClassNodekitCatalog():
  """SoTranslate2Dragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoTranslate2Dragger_getClassNodekitCatalog()

def SoTranslate2Dragger_initClass():
  """SoTranslate2Dragger_initClass()"""
  return _coin.SoTranslate2Dragger_initClass()

class SoAccumulatedElement(SoElement):
    """Proxy of C++ SoAccumulatedElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoAccumulatedElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoAccumulatedElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def initClass():
        """initClass()"""
        return _coin.SoAccumulatedElement_initClass()

    initClass = staticmethod(initClass)
    def matches(self, *args):
        """matches(self, SoElement element) -> SbBool"""
        return _coin.SoAccumulatedElement_matches(self, *args)

SoAccumulatedElement_swigregister = _coin.SoAccumulatedElement_swigregister
SoAccumulatedElement_swigregister(SoAccumulatedElement)

def SoAccumulatedElement_getClassTypeId():
  """SoAccumulatedElement_getClassTypeId() -> SoType"""
  return _coin.SoAccumulatedElement_getClassTypeId()

def SoAccumulatedElement_getClassStackIndex():
  """SoAccumulatedElement_getClassStackIndex() -> int"""
  return _coin.SoAccumulatedElement_getClassStackIndex()

def SoAccumulatedElement_initClass():
  """SoAccumulatedElement_initClass()"""
  return _coin.SoAccumulatedElement_initClass()

class SoAmbientColorElement(SoReplacedElement):
    """Proxy of C++ SoAmbientColorElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoAmbientColorElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoAmbientColorElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoAmbientColorElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoAmbientColorElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoAmbientColorElement_init(self, *args)

    def set(*args):
        """set(SoState state, SoNode node, int32_t numcolors, SbColor colors)"""
        return _coin.SoAmbientColorElement_set(*args)

    set = staticmethod(set)
    def getInstance(*args):
        """getInstance(SoState state) -> SoAmbientColorElement"""
        return _coin.SoAmbientColorElement_getInstance(*args)

    getInstance = staticmethod(getInstance)
    def getNum(self):
        """getNum(self) -> int32_t"""
        return _coin.SoAmbientColorElement_getNum(self)

    def get(self, *args):
        """get(self, int index) -> SbColor"""
        return _coin.SoAmbientColorElement_get(self, *args)

    def getArrayPtr(self):
        """getArrayPtr(self) -> SbColor"""
        return _coin.SoAmbientColorElement_getArrayPtr(self)

SoAmbientColorElement_swigregister = _coin.SoAmbientColorElement_swigregister
SoAmbientColorElement_swigregister(SoAmbientColorElement)

def SoAmbientColorElement_getClassTypeId():
  """SoAmbientColorElement_getClassTypeId() -> SoType"""
  return _coin.SoAmbientColorElement_getClassTypeId()

def SoAmbientColorElement_getClassStackIndex():
  """SoAmbientColorElement_getClassStackIndex() -> int"""
  return _coin.SoAmbientColorElement_getClassStackIndex()

def SoAmbientColorElement_createInstance():
  """SoAmbientColorElement_createInstance() -> void"""
  return _coin.SoAmbientColorElement_createInstance()

def SoAmbientColorElement_initClass():
  """SoAmbientColorElement_initClass()"""
  return _coin.SoAmbientColorElement_initClass()

def SoAmbientColorElement_set(*args):
  """SoAmbientColorElement_set(SoState state, SoNode node, int32_t numcolors, SbColor colors)"""
  return _coin.SoAmbientColorElement_set(*args)

def SoAmbientColorElement_getInstance(*args):
  """SoAmbientColorElement_getInstance(SoState state) -> SoAmbientColorElement"""
  return _coin.SoAmbientColorElement_getInstance(*args)

class SoAnnoText3CharOrientElement(SoInt32Element):
    """Proxy of C++ SoAnnoText3CharOrientElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoAnnoText3CharOrientElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoAnnoText3CharOrientElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoAnnoText3CharOrientElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoAnnoText3CharOrientElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoAnnoText3CharOrientElement_init(self, *args)

    def set(*args):
        """set(SoState state, SbBool isOriented)"""
        return _coin.SoAnnoText3CharOrientElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> SbBool"""
        return _coin.SoAnnoText3CharOrientElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> SbBool"""
        return _coin.SoAnnoText3CharOrientElement_getDefault()

    getDefault = staticmethod(getDefault)
SoAnnoText3CharOrientElement_swigregister = _coin.SoAnnoText3CharOrientElement_swigregister
SoAnnoText3CharOrientElement_swigregister(SoAnnoText3CharOrientElement)

def SoAnnoText3CharOrientElement_getClassTypeId():
  """SoAnnoText3CharOrientElement_getClassTypeId() -> SoType"""
  return _coin.SoAnnoText3CharOrientElement_getClassTypeId()

def SoAnnoText3CharOrientElement_getClassStackIndex():
  """SoAnnoText3CharOrientElement_getClassStackIndex() -> int"""
  return _coin.SoAnnoText3CharOrientElement_getClassStackIndex()

def SoAnnoText3CharOrientElement_createInstance():
  """SoAnnoText3CharOrientElement_createInstance() -> void"""
  return _coin.SoAnnoText3CharOrientElement_createInstance()

def SoAnnoText3CharOrientElement_initClass():
  """SoAnnoText3CharOrientElement_initClass()"""
  return _coin.SoAnnoText3CharOrientElement_initClass()

def SoAnnoText3CharOrientElement_set(*args):
  """SoAnnoText3CharOrientElement_set(SoState state, SbBool isOriented)"""
  return _coin.SoAnnoText3CharOrientElement_set(*args)

def SoAnnoText3CharOrientElement_get(*args):
  """SoAnnoText3CharOrientElement_get(SoState state) -> SbBool"""
  return _coin.SoAnnoText3CharOrientElement_get(*args)

def SoAnnoText3CharOrientElement_getDefault():
  """SoAnnoText3CharOrientElement_getDefault() -> SbBool"""
  return _coin.SoAnnoText3CharOrientElement_getDefault()

class SoAnnoText3FontSizeHintElement(SoInt32Element):
    """Proxy of C++ SoAnnoText3FontSizeHintElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoAnnoText3FontSizeHintElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoAnnoText3FontSizeHintElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoAnnoText3FontSizeHintElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoAnnoText3FontSizeHintElement_initClass()

    initClass = staticmethod(initClass)
    ANNOTATION = _coin.SoAnnoText3FontSizeHintElement_ANNOTATION
    FIT_TEXT_VECTOR = _coin.SoAnnoText3FontSizeHintElement_FIT_TEXT_VECTOR
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoAnnoText3FontSizeHintElement_init(self, *args)

    def get(*args):
        """get(SoState state) -> FontSizeHint"""
        return _coin.SoAnnoText3FontSizeHintElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> FontSizeHint"""
        return _coin.SoAnnoText3FontSizeHintElement_getDefault()

    getDefault = staticmethod(getDefault)
    def set(*args):
        """
        set(SoState state, FontSizeHint hint)
        set(SoState state, SoNode node, FontSizeHint hint)
        """
        return _coin.SoAnnoText3FontSizeHintElement_set(*args)

    set = staticmethod(set)
SoAnnoText3FontSizeHintElement_swigregister = _coin.SoAnnoText3FontSizeHintElement_swigregister
SoAnnoText3FontSizeHintElement_swigregister(SoAnnoText3FontSizeHintElement)

def SoAnnoText3FontSizeHintElement_getClassTypeId():
  """SoAnnoText3FontSizeHintElement_getClassTypeId() -> SoType"""
  return _coin.SoAnnoText3FontSizeHintElement_getClassTypeId()

def SoAnnoText3FontSizeHintElement_getClassStackIndex():
  """SoAnnoText3FontSizeHintElement_getClassStackIndex() -> int"""
  return _coin.SoAnnoText3FontSizeHintElement_getClassStackIndex()

def SoAnnoText3FontSizeHintElement_createInstance():
  """SoAnnoText3FontSizeHintElement_createInstance() -> void"""
  return _coin.SoAnnoText3FontSizeHintElement_createInstance()

def SoAnnoText3FontSizeHintElement_initClass():
  """SoAnnoText3FontSizeHintElement_initClass()"""
  return _coin.SoAnnoText3FontSizeHintElement_initClass()

def SoAnnoText3FontSizeHintElement_get(*args):
  """SoAnnoText3FontSizeHintElement_get(SoState state) -> FontSizeHint"""
  return _coin.SoAnnoText3FontSizeHintElement_get(*args)

def SoAnnoText3FontSizeHintElement_getDefault():
  """SoAnnoText3FontSizeHintElement_getDefault() -> FontSizeHint"""
  return _coin.SoAnnoText3FontSizeHintElement_getDefault()

def SoAnnoText3FontSizeHintElement_set(*args):
  """
    set(SoState state, FontSizeHint hint)
    SoAnnoText3FontSizeHintElement_set(SoState state, SoNode node, FontSizeHint hint)
    """
  return _coin.SoAnnoText3FontSizeHintElement_set(*args)

class SoAnnoText3RenderPrintElement(SoInt32Element):
    """Proxy of C++ SoAnnoText3RenderPrintElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoAnnoText3RenderPrintElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoAnnoText3RenderPrintElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoAnnoText3RenderPrintElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoAnnoText3RenderPrintElement_initClass()

    initClass = staticmethod(initClass)
    RENDER3D_PRINT_VECTOR = _coin.SoAnnoText3RenderPrintElement_RENDER3D_PRINT_VECTOR
    RENDER3D_PRINT_RASTER = _coin.SoAnnoText3RenderPrintElement_RENDER3D_PRINT_RASTER
    RENDER2D_PRINT_RASTER = _coin.SoAnnoText3RenderPrintElement_RENDER2D_PRINT_RASTER
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoAnnoText3RenderPrintElement_init(self, *args)

    def get(*args):
        """get(SoState state) -> RenderPrintType"""
        return _coin.SoAnnoText3RenderPrintElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> RenderPrintType"""
        return _coin.SoAnnoText3RenderPrintElement_getDefault()

    getDefault = staticmethod(getDefault)
    def set(*args):
        """
        set(SoState state, RenderPrintType hint)
        set(SoState state, SoNode node, RenderPrintType type)
        """
        return _coin.SoAnnoText3RenderPrintElement_set(*args)

    set = staticmethod(set)
SoAnnoText3RenderPrintElement_swigregister = _coin.SoAnnoText3RenderPrintElement_swigregister
SoAnnoText3RenderPrintElement_swigregister(SoAnnoText3RenderPrintElement)

def SoAnnoText3RenderPrintElement_getClassTypeId():
  """SoAnnoText3RenderPrintElement_getClassTypeId() -> SoType"""
  return _coin.SoAnnoText3RenderPrintElement_getClassTypeId()

def SoAnnoText3RenderPrintElement_getClassStackIndex():
  """SoAnnoText3RenderPrintElement_getClassStackIndex() -> int"""
  return _coin.SoAnnoText3RenderPrintElement_getClassStackIndex()

def SoAnnoText3RenderPrintElement_createInstance():
  """SoAnnoText3RenderPrintElement_createInstance() -> void"""
  return _coin.SoAnnoText3RenderPrintElement_createInstance()

def SoAnnoText3RenderPrintElement_initClass():
  """SoAnnoText3RenderPrintElement_initClass()"""
  return _coin.SoAnnoText3RenderPrintElement_initClass()

def SoAnnoText3RenderPrintElement_get(*args):
  """SoAnnoText3RenderPrintElement_get(SoState state) -> RenderPrintType"""
  return _coin.SoAnnoText3RenderPrintElement_get(*args)

def SoAnnoText3RenderPrintElement_getDefault():
  """SoAnnoText3RenderPrintElement_getDefault() -> RenderPrintType"""
  return _coin.SoAnnoText3RenderPrintElement_getDefault()

def SoAnnoText3RenderPrintElement_set(*args):
  """
    set(SoState state, RenderPrintType hint)
    SoAnnoText3RenderPrintElement_set(SoState state, SoNode node, RenderPrintType type)
    """
  return _coin.SoAnnoText3RenderPrintElement_set(*args)

class SoModelMatrixElement(SoAccumulatedElement):
    """Proxy of C++ SoModelMatrixElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoModelMatrixElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoModelMatrixElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoModelMatrixElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoModelMatrixElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoModelMatrixElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoModelMatrixElement_push(self, *args)

    def matches(self, *args):
        """matches(self, SoElement element) -> SbBool"""
        return _coin.SoModelMatrixElement_matches(self, *args)

    def makeIdentity(*args):
        """makeIdentity(SoState state, SoNode node)"""
        return _coin.SoModelMatrixElement_makeIdentity(*args)

    makeIdentity = staticmethod(makeIdentity)
    def set(*args):
        """set(SoState state, SoNode node)"""
        return _coin.SoModelMatrixElement_set(*args)

    set = staticmethod(set)
    def setCullMatrix(*args):
        """setCullMatrix(SoState state, SoNode node)"""
        return _coin.SoModelMatrixElement_setCullMatrix(*args)

    setCullMatrix = staticmethod(setCullMatrix)
    def mult(*args):
        """mult(SoState state, SoNode node)"""
        return _coin.SoModelMatrixElement_mult(*args)

    mult = staticmethod(mult)
    def translateBy(*args):
        """translateBy(SoState state, SoNode node, SbVec3f translation)"""
        return _coin.SoModelMatrixElement_translateBy(*args)

    translateBy = staticmethod(translateBy)
    def rotateBy(*args):
        """rotateBy(SoState state, SoNode node, SbRotation rotation)"""
        return _coin.SoModelMatrixElement_rotateBy(*args)

    rotateBy = staticmethod(rotateBy)
    def scaleBy(*args):
        """scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"""
        return _coin.SoModelMatrixElement_scaleBy(*args)

    scaleBy = staticmethod(scaleBy)
    def pushMatrix(*args):
        """pushMatrix(SoState state) -> SbMatrix"""
        return _coin.SoModelMatrixElement_pushMatrix(*args)

    pushMatrix = staticmethod(pushMatrix)
    def popMatrix(*args):
        """popMatrix(SoState state)"""
        return _coin.SoModelMatrixElement_popMatrix(*args)

    popMatrix = staticmethod(popMatrix)
    def getCombinedCullMatrix(*args):
        """getCombinedCullMatrix(SoState state) -> SbMatrix"""
        return _coin.SoModelMatrixElement_getCombinedCullMatrix(*args)

    getCombinedCullMatrix = staticmethod(getCombinedCullMatrix)
    def get(*args):
        """
        get(SoState state) -> SbMatrix
        get(SoState state, SbBool isIdentity) -> SbMatrix
        """
        return _coin.SoModelMatrixElement_get(*args)

    get = staticmethod(get)
    def getModelMatrix(self):
        """getModelMatrix(self) -> SbMatrix"""
        return _coin.SoModelMatrixElement_getModelMatrix(self)

SoModelMatrixElement_swigregister = _coin.SoModelMatrixElement_swigregister
SoModelMatrixElement_swigregister(SoModelMatrixElement)

def SoModelMatrixElement_getClassTypeId():
  """SoModelMatrixElement_getClassTypeId() -> SoType"""
  return _coin.SoModelMatrixElement_getClassTypeId()

def SoModelMatrixElement_getClassStackIndex():
  """SoModelMatrixElement_getClassStackIndex() -> int"""
  return _coin.SoModelMatrixElement_getClassStackIndex()

def SoModelMatrixElement_createInstance():
  """SoModelMatrixElement_createInstance() -> void"""
  return _coin.SoModelMatrixElement_createInstance()

def SoModelMatrixElement_initClass():
  """SoModelMatrixElement_initClass()"""
  return _coin.SoModelMatrixElement_initClass()

def SoModelMatrixElement_makeIdentity(*args):
  """SoModelMatrixElement_makeIdentity(SoState state, SoNode node)"""
  return _coin.SoModelMatrixElement_makeIdentity(*args)

def SoModelMatrixElement_set(*args):
  """SoModelMatrixElement_set(SoState state, SoNode node)"""
  return _coin.SoModelMatrixElement_set(*args)

def SoModelMatrixElement_setCullMatrix(*args):
  """SoModelMatrixElement_setCullMatrix(SoState state, SoNode node)"""
  return _coin.SoModelMatrixElement_setCullMatrix(*args)

def SoModelMatrixElement_mult(*args):
  """SoModelMatrixElement_mult(SoState state, SoNode node)"""
  return _coin.SoModelMatrixElement_mult(*args)

def SoModelMatrixElement_translateBy(*args):
  """SoModelMatrixElement_translateBy(SoState state, SoNode node, SbVec3f translation)"""
  return _coin.SoModelMatrixElement_translateBy(*args)

def SoModelMatrixElement_rotateBy(*args):
  """SoModelMatrixElement_rotateBy(SoState state, SoNode node, SbRotation rotation)"""
  return _coin.SoModelMatrixElement_rotateBy(*args)

def SoModelMatrixElement_scaleBy(*args):
  """SoModelMatrixElement_scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"""
  return _coin.SoModelMatrixElement_scaleBy(*args)

def SoModelMatrixElement_pushMatrix(*args):
  """SoModelMatrixElement_pushMatrix(SoState state) -> SbMatrix"""
  return _coin.SoModelMatrixElement_pushMatrix(*args)

def SoModelMatrixElement_popMatrix(*args):
  """SoModelMatrixElement_popMatrix(SoState state)"""
  return _coin.SoModelMatrixElement_popMatrix(*args)

def SoModelMatrixElement_getCombinedCullMatrix(*args):
  """SoModelMatrixElement_getCombinedCullMatrix(SoState state) -> SbMatrix"""
  return _coin.SoModelMatrixElement_getCombinedCullMatrix(*args)

def SoModelMatrixElement_get(*args):
  """
    get(SoState state) -> SbMatrix
    SoModelMatrixElement_get(SoState state, SbBool isIdentity) -> SbMatrix
    """
  return _coin.SoModelMatrixElement_get(*args)

class SoBBoxModelMatrixElement(SoModelMatrixElement):
    """Proxy of C++ SoBBoxModelMatrixElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoBBoxModelMatrixElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoBBoxModelMatrixElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoBBoxModelMatrixElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoBBoxModelMatrixElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoBBoxModelMatrixElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoBBoxModelMatrixElement_push(self, *args)

    def reset(*args):
        """reset(SoState state, SoNode node)"""
        return _coin.SoBBoxModelMatrixElement_reset(*args)

    reset = staticmethod(reset)
    def pushMatrix(*args):
        """pushMatrix(SoState state, SbMatrix localmatrix)"""
        return _coin.SoBBoxModelMatrixElement_pushMatrix(*args)

    pushMatrix = staticmethod(pushMatrix)
    def popMatrix(*args):
        """popMatrix(SoState state, SbMatrix localmatrix)"""
        return _coin.SoBBoxModelMatrixElement_popMatrix(*args)

    popMatrix = staticmethod(popMatrix)
SoBBoxModelMatrixElement_swigregister = _coin.SoBBoxModelMatrixElement_swigregister
SoBBoxModelMatrixElement_swigregister(SoBBoxModelMatrixElement)

def SoBBoxModelMatrixElement_getClassTypeId():
  """SoBBoxModelMatrixElement_getClassTypeId() -> SoType"""
  return _coin.SoBBoxModelMatrixElement_getClassTypeId()

def SoBBoxModelMatrixElement_getClassStackIndex():
  """SoBBoxModelMatrixElement_getClassStackIndex() -> int"""
  return _coin.SoBBoxModelMatrixElement_getClassStackIndex()

def SoBBoxModelMatrixElement_createInstance():
  """SoBBoxModelMatrixElement_createInstance() -> void"""
  return _coin.SoBBoxModelMatrixElement_createInstance()

def SoBBoxModelMatrixElement_initClass():
  """SoBBoxModelMatrixElement_initClass()"""
  return _coin.SoBBoxModelMatrixElement_initClass()

def SoBBoxModelMatrixElement_reset(*args):
  """SoBBoxModelMatrixElement_reset(SoState state, SoNode node)"""
  return _coin.SoBBoxModelMatrixElement_reset(*args)

def SoBBoxModelMatrixElement_pushMatrix(*args):
  """SoBBoxModelMatrixElement_pushMatrix(SoState state, SbMatrix localmatrix)"""
  return _coin.SoBBoxModelMatrixElement_pushMatrix(*args)

def SoBBoxModelMatrixElement_popMatrix(*args):
  """SoBBoxModelMatrixElement_popMatrix(SoState state, SbMatrix localmatrix)"""
  return _coin.SoBBoxModelMatrixElement_popMatrix(*args)

class SoBumpMapCoordinateElement(SoReplacedElement):
    """Proxy of C++ SoBumpMapCoordinateElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoBumpMapCoordinateElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoBumpMapCoordinateElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoBumpMapCoordinateElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoBumpMapCoordinateElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoBumpMapCoordinateElement_init(self, *args)

    def set(*args):
        """set(SoState state, SoNode node, int32_t numcoords, SbVec2f coords)"""
        return _coin.SoBumpMapCoordinateElement_set(*args)

    set = staticmethod(set)
    def getInstance(*args):
        """getInstance(SoState state) -> SoBumpMapCoordinateElement"""
        return _coin.SoBumpMapCoordinateElement_getInstance(*args)

    getInstance = staticmethod(getInstance)
    def getNum(self):
        """getNum(self) -> int32_t"""
        return _coin.SoBumpMapCoordinateElement_getNum(self)

    def get(self, *args):
        """get(self, int index) -> SbVec2f"""
        return _coin.SoBumpMapCoordinateElement_get(self, *args)

    def getArrayPtr(self):
        """getArrayPtr(self) -> SbVec2f"""
        return _coin.SoBumpMapCoordinateElement_getArrayPtr(self)

SoBumpMapCoordinateElement_swigregister = _coin.SoBumpMapCoordinateElement_swigregister
SoBumpMapCoordinateElement_swigregister(SoBumpMapCoordinateElement)

def SoBumpMapCoordinateElement_getClassTypeId():
  """SoBumpMapCoordinateElement_getClassTypeId() -> SoType"""
  return _coin.SoBumpMapCoordinateElement_getClassTypeId()

def SoBumpMapCoordinateElement_getClassStackIndex():
  """SoBumpMapCoordinateElement_getClassStackIndex() -> int"""
  return _coin.SoBumpMapCoordinateElement_getClassStackIndex()

def SoBumpMapCoordinateElement_createInstance():
  """SoBumpMapCoordinateElement_createInstance() -> void"""
  return _coin.SoBumpMapCoordinateElement_createInstance()

def SoBumpMapCoordinateElement_initClass():
  """SoBumpMapCoordinateElement_initClass()"""
  return _coin.SoBumpMapCoordinateElement_initClass()

def SoBumpMapCoordinateElement_set(*args):
  """SoBumpMapCoordinateElement_set(SoState state, SoNode node, int32_t numcoords, SbVec2f coords)"""
  return _coin.SoBumpMapCoordinateElement_set(*args)

def SoBumpMapCoordinateElement_getInstance(*args):
  """SoBumpMapCoordinateElement_getInstance(SoState state) -> SoBumpMapCoordinateElement"""
  return _coin.SoBumpMapCoordinateElement_getInstance(*args)

class SoBumpMapElement(SoReplacedElement):
    """Proxy of C++ SoBumpMapElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoBumpMapElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoBumpMapElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoBumpMapElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoBumpMapElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoBumpMapElement_init(self, *args)

    def set(*args):
        """set(SoState state, SoNode node, SoGLImage image)"""
        return _coin.SoBumpMapElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> SoGLImage"""
        return _coin.SoBumpMapElement_get(*args)

    get = staticmethod(get)
SoBumpMapElement_swigregister = _coin.SoBumpMapElement_swigregister
SoBumpMapElement_swigregister(SoBumpMapElement)

def SoBumpMapElement_getClassTypeId():
  """SoBumpMapElement_getClassTypeId() -> SoType"""
  return _coin.SoBumpMapElement_getClassTypeId()

def SoBumpMapElement_getClassStackIndex():
  """SoBumpMapElement_getClassStackIndex() -> int"""
  return _coin.SoBumpMapElement_getClassStackIndex()

def SoBumpMapElement_createInstance():
  """SoBumpMapElement_createInstance() -> void"""
  return _coin.SoBumpMapElement_createInstance()

def SoBumpMapElement_initClass():
  """SoBumpMapElement_initClass()"""
  return _coin.SoBumpMapElement_initClass()

def SoBumpMapElement_set(*args):
  """SoBumpMapElement_set(SoState state, SoNode node, SoGLImage image)"""
  return _coin.SoBumpMapElement_set(*args)

def SoBumpMapElement_get(*args):
  """SoBumpMapElement_get(SoState state) -> SoGLImage"""
  return _coin.SoBumpMapElement_get(*args)

class SoBumpMapMatrixElement(SoAccumulatedElement):
    """Proxy of C++ SoBumpMapMatrixElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoBumpMapMatrixElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoBumpMapMatrixElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoBumpMapMatrixElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoBumpMapMatrixElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoBumpMapMatrixElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoBumpMapMatrixElement_push(self, *args)

    def makeIdentity(*args):
        """makeIdentity(SoState state, SoNode node)"""
        return _coin.SoBumpMapMatrixElement_makeIdentity(*args)

    makeIdentity = staticmethod(makeIdentity)
    def set(*args):
        """set(SoState state, SoNode node)"""
        return _coin.SoBumpMapMatrixElement_set(*args)

    set = staticmethod(set)
    def mult(*args):
        """mult(SoState state, SoNode node)"""
        return _coin.SoBumpMapMatrixElement_mult(*args)

    mult = staticmethod(mult)
    def translateBy(*args):
        """translateBy(SoState state, SoNode node, SbVec3f translation)"""
        return _coin.SoBumpMapMatrixElement_translateBy(*args)

    translateBy = staticmethod(translateBy)
    def rotateBy(*args):
        """rotateBy(SoState state, SoNode node, SbRotation rotation)"""
        return _coin.SoBumpMapMatrixElement_rotateBy(*args)

    rotateBy = staticmethod(rotateBy)
    def scaleBy(*args):
        """scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"""
        return _coin.SoBumpMapMatrixElement_scaleBy(*args)

    scaleBy = staticmethod(scaleBy)
    def get(*args):
        """get(SoState state) -> SbMatrix"""
        return _coin.SoBumpMapMatrixElement_get(*args)

    get = staticmethod(get)
SoBumpMapMatrixElement_swigregister = _coin.SoBumpMapMatrixElement_swigregister
SoBumpMapMatrixElement_swigregister(SoBumpMapMatrixElement)

def SoBumpMapMatrixElement_getClassTypeId():
  """SoBumpMapMatrixElement_getClassTypeId() -> SoType"""
  return _coin.SoBumpMapMatrixElement_getClassTypeId()

def SoBumpMapMatrixElement_getClassStackIndex():
  """SoBumpMapMatrixElement_getClassStackIndex() -> int"""
  return _coin.SoBumpMapMatrixElement_getClassStackIndex()

def SoBumpMapMatrixElement_createInstance():
  """SoBumpMapMatrixElement_createInstance() -> void"""
  return _coin.SoBumpMapMatrixElement_createInstance()

def SoBumpMapMatrixElement_initClass():
  """SoBumpMapMatrixElement_initClass()"""
  return _coin.SoBumpMapMatrixElement_initClass()

def SoBumpMapMatrixElement_makeIdentity(*args):
  """SoBumpMapMatrixElement_makeIdentity(SoState state, SoNode node)"""
  return _coin.SoBumpMapMatrixElement_makeIdentity(*args)

def SoBumpMapMatrixElement_set(*args):
  """SoBumpMapMatrixElement_set(SoState state, SoNode node)"""
  return _coin.SoBumpMapMatrixElement_set(*args)

def SoBumpMapMatrixElement_mult(*args):
  """SoBumpMapMatrixElement_mult(SoState state, SoNode node)"""
  return _coin.SoBumpMapMatrixElement_mult(*args)

def SoBumpMapMatrixElement_translateBy(*args):
  """SoBumpMapMatrixElement_translateBy(SoState state, SoNode node, SbVec3f translation)"""
  return _coin.SoBumpMapMatrixElement_translateBy(*args)

def SoBumpMapMatrixElement_rotateBy(*args):
  """SoBumpMapMatrixElement_rotateBy(SoState state, SoNode node, SbRotation rotation)"""
  return _coin.SoBumpMapMatrixElement_rotateBy(*args)

def SoBumpMapMatrixElement_scaleBy(*args):
  """SoBumpMapMatrixElement_scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"""
  return _coin.SoBumpMapMatrixElement_scaleBy(*args)

def SoBumpMapMatrixElement_get(*args):
  """SoBumpMapMatrixElement_get(SoState state) -> SbMatrix"""
  return _coin.SoBumpMapMatrixElement_get(*args)

class SoCacheElement(SoElement):
    """Proxy of C++ SoCacheElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoCacheElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoCacheElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoCacheElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoCacheElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoCacheElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoCacheElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoCacheElement_pop(self, *args)

    def set(*args):
        """set(SoState state, SoCache cache)"""
        return _coin.SoCacheElement_set(*args)

    set = staticmethod(set)
    def getCache(self):
        """getCache(self) -> SoCache"""
        return _coin.SoCacheElement_getCache(self)

    def anyOpen(*args):
        """anyOpen(SoState state) -> SbBool"""
        return _coin.SoCacheElement_anyOpen(*args)

    anyOpen = staticmethod(anyOpen)
    def invalidate(*args):
        """invalidate(SoState state)"""
        return _coin.SoCacheElement_invalidate(*args)

    invalidate = staticmethod(invalidate)
    def matches(self, *args):
        """matches(self, SoElement element) -> SbBool"""
        return _coin.SoCacheElement_matches(self, *args)

    def copyMatchInfo(self):
        """copyMatchInfo(self) -> SoElement"""
        return _coin.SoCacheElement_copyMatchInfo(self)

    def getNextCacheElement(self):
        """getNextCacheElement(self) -> SoCacheElement"""
        return _coin.SoCacheElement_getNextCacheElement(self)

    def addElement(*args):
        """addElement(SoState state, SoElement element)"""
        return _coin.SoCacheElement_addElement(*args)

    addElement = staticmethod(addElement)
    def addCacheDependency(*args):
        """addCacheDependency(SoState state, SoCache cache)"""
        return _coin.SoCacheElement_addCacheDependency(*args)

    addCacheDependency = staticmethod(addCacheDependency)
    def setInvalid(*args):
        """setInvalid(SbBool newvalue) -> SbBool"""
        return _coin.SoCacheElement_setInvalid(*args)

    setInvalid = staticmethod(setInvalid)
    def getCurrentCache(*args):
        """getCurrentCache(SoState state) -> SoCache"""
        return _coin.SoCacheElement_getCurrentCache(*args)

    getCurrentCache = staticmethod(getCurrentCache)
SoCacheElement_swigregister = _coin.SoCacheElement_swigregister
SoCacheElement_swigregister(SoCacheElement)

def SoCacheElement_getClassTypeId():
  """SoCacheElement_getClassTypeId() -> SoType"""
  return _coin.SoCacheElement_getClassTypeId()

def SoCacheElement_getClassStackIndex():
  """SoCacheElement_getClassStackIndex() -> int"""
  return _coin.SoCacheElement_getClassStackIndex()

def SoCacheElement_createInstance():
  """SoCacheElement_createInstance() -> void"""
  return _coin.SoCacheElement_createInstance()

def SoCacheElement_initClass():
  """SoCacheElement_initClass()"""
  return _coin.SoCacheElement_initClass()

def SoCacheElement_set(*args):
  """SoCacheElement_set(SoState state, SoCache cache)"""
  return _coin.SoCacheElement_set(*args)

def SoCacheElement_anyOpen(*args):
  """SoCacheElement_anyOpen(SoState state) -> SbBool"""
  return _coin.SoCacheElement_anyOpen(*args)

def SoCacheElement_invalidate(*args):
  """SoCacheElement_invalidate(SoState state)"""
  return _coin.SoCacheElement_invalidate(*args)

def SoCacheElement_addElement(*args):
  """SoCacheElement_addElement(SoState state, SoElement element)"""
  return _coin.SoCacheElement_addElement(*args)

def SoCacheElement_addCacheDependency(*args):
  """SoCacheElement_addCacheDependency(SoState state, SoCache cache)"""
  return _coin.SoCacheElement_addCacheDependency(*args)

def SoCacheElement_setInvalid(*args):
  """SoCacheElement_setInvalid(SbBool newvalue) -> SbBool"""
  return _coin.SoCacheElement_setInvalid(*args)

def SoCacheElement_getCurrentCache(*args):
  """SoCacheElement_getCurrentCache(SoState state) -> SoCache"""
  return _coin.SoCacheElement_getCurrentCache(*args)

class SbPlane(object):
    """Proxy of C++ SbPlane class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbPlane
        __init__(self, SbVec3f normal, float D) -> SbPlane
        __init__(self, SbVec3f p0, SbVec3f p1, SbVec3f p2) -> SbPlane
        __init__(self, SbVec3f normal, SbVec3f point) -> SbPlane
        """
        this = _coin.new_SbPlane(*args)
        try: self.this.append(this)
        except: self.this = this
    def offset(self, *args):
        """offset(self, float d)"""
        return _coin.SbPlane_offset(self, *args)

    def transform(self):
        """transform(self)"""
        return _coin.SbPlane_transform(self)

    def isInHalfSpace(self, *args):
        """isInHalfSpace(self, SbVec3f point) -> SbBool"""
        return _coin.SbPlane_isInHalfSpace(self, *args)

    def getDistance(self, *args):
        """getDistance(self, SbVec3f point) -> float"""
        return _coin.SbPlane_getDistance(self, *args)

    def getNormal(self):
        """getNormal(self) -> SbVec3f"""
        return _coin.SbPlane_getNormal(self)

    def getDistanceFromOrigin(self):
        """getDistanceFromOrigin(self) -> float"""
        return _coin.SbPlane_getDistanceFromOrigin(self)

    def output(self, *args):
        """output(self, FILE file)"""
        return _coin.SbPlane_output(self, *args)

    def intersect(self, *args):
        """
        intersect(self, SbLine l, SbVec3f intersection) -> SbBool
        intersect(self, SbPlane pl, SbLine line) -> SbBool
        """
        return _coin.SbPlane_intersect(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SbPlane u) -> int"""
        return _coin.SbPlane___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SbPlane u) -> int"""
        return _coin.SbPlane___ne__(self, *args)

    __swig_destroy__ = _coin.delete_SbPlane
    __del__ = lambda self : None;
SbPlane_swigregister = _coin.SbPlane_swigregister
SbPlane_swigregister(SbPlane)

class SoClipPlaneElement(SoAccumulatedElement):
    """Proxy of C++ SoClipPlaneElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoClipPlaneElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoClipPlaneElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoClipPlaneElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoClipPlaneElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoClipPlaneElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoClipPlaneElement_push(self, *args)

    def add(*args):
        """add(SoState state, SoNode node, SbPlane plane)"""
        return _coin.SoClipPlaneElement_add(*args)

    add = staticmethod(add)
    def getInstance(*args):
        """getInstance(SoState state) -> SoClipPlaneElement"""
        return _coin.SoClipPlaneElement_getInstance(*args)

    getInstance = staticmethod(getInstance)
    def getNum(self):
        """getNum(self) -> int"""
        return _coin.SoClipPlaneElement_getNum(self)

    def get(self, *args):
        """
        get(self, int index, SbBool inworldspace = 1) -> SbPlane
        get(self, int index) -> SbPlane
        """
        return _coin.SoClipPlaneElement_get(self, *args)

SoClipPlaneElement_swigregister = _coin.SoClipPlaneElement_swigregister
SoClipPlaneElement_swigregister(SoClipPlaneElement)

def SoClipPlaneElement_getClassTypeId():
  """SoClipPlaneElement_getClassTypeId() -> SoType"""
  return _coin.SoClipPlaneElement_getClassTypeId()

def SoClipPlaneElement_getClassStackIndex():
  """SoClipPlaneElement_getClassStackIndex() -> int"""
  return _coin.SoClipPlaneElement_getClassStackIndex()

def SoClipPlaneElement_createInstance():
  """SoClipPlaneElement_createInstance() -> void"""
  return _coin.SoClipPlaneElement_createInstance()

def SoClipPlaneElement_initClass():
  """SoClipPlaneElement_initClass()"""
  return _coin.SoClipPlaneElement_initClass()

def SoClipPlaneElement_add(*args):
  """SoClipPlaneElement_add(SoState state, SoNode node, SbPlane plane)"""
  return _coin.SoClipPlaneElement_add(*args)

def SoClipPlaneElement_getInstance(*args):
  """SoClipPlaneElement_getInstance(SoState state) -> SoClipPlaneElement"""
  return _coin.SoClipPlaneElement_getInstance(*args)

class SoFloatElement(SoElement):
    """Proxy of C++ SoFloatElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoFloatElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoFloatElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def initClass():
        """initClass()"""
        return _coin.SoFloatElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoFloatElement_init(self, *args)

    def matches(self, *args):
        """matches(self, SoElement element) -> SbBool"""
        return _coin.SoFloatElement_matches(self, *args)

    def copyMatchInfo(self):
        """copyMatchInfo(self) -> SoElement"""
        return _coin.SoFloatElement_copyMatchInfo(self)

    def output(self, *args):
        """output(self, FILE file)"""
        return _coin.SoFloatElement_output(self, *args)

    def set(*args):
        """
        set(int stackIndex, SoState state, SoNode node, float value)
        set(int stackIndex, SoState state, float value)
        """
        return _coin.SoFloatElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(int stackIndex, SoState state) -> float"""
        return _coin.SoFloatElement_get(*args)

    get = staticmethod(get)
    def setElt(self, *args):
        """setElt(self, float value)"""
        return _coin.SoFloatElement_setElt(self, *args)

SoFloatElement_swigregister = _coin.SoFloatElement_swigregister
SoFloatElement_swigregister(SoFloatElement)

def SoFloatElement_getClassTypeId():
  """SoFloatElement_getClassTypeId() -> SoType"""
  return _coin.SoFloatElement_getClassTypeId()

def SoFloatElement_getClassStackIndex():
  """SoFloatElement_getClassStackIndex() -> int"""
  return _coin.SoFloatElement_getClassStackIndex()

def SoFloatElement_initClass():
  """SoFloatElement_initClass()"""
  return _coin.SoFloatElement_initClass()

def SoFloatElement_set(*args):
  """
    set(int stackIndex, SoState state, SoNode node, float value)
    SoFloatElement_set(int stackIndex, SoState state, float value)
    """
  return _coin.SoFloatElement_set(*args)

def SoFloatElement_get(*args):
  """SoFloatElement_get(int stackIndex, SoState state) -> float"""
  return _coin.SoFloatElement_get(*args)

class SoComplexityElement(SoFloatElement):
    """Proxy of C++ SoComplexityElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoComplexityElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoComplexityElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoComplexityElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoComplexityElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoComplexityElement_init(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, float complexity)
        set(SoState state, float complexity)
        """
        return _coin.SoComplexityElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> float"""
        return _coin.SoComplexityElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> float"""
        return _coin.SoComplexityElement_getDefault()

    getDefault = staticmethod(getDefault)
SoComplexityElement_swigregister = _coin.SoComplexityElement_swigregister
SoComplexityElement_swigregister(SoComplexityElement)

def SoComplexityElement_getClassTypeId():
  """SoComplexityElement_getClassTypeId() -> SoType"""
  return _coin.SoComplexityElement_getClassTypeId()

def SoComplexityElement_getClassStackIndex():
  """SoComplexityElement_getClassStackIndex() -> int"""
  return _coin.SoComplexityElement_getClassStackIndex()

def SoComplexityElement_createInstance():
  """SoComplexityElement_createInstance() -> void"""
  return _coin.SoComplexityElement_createInstance()

def SoComplexityElement_initClass():
  """SoComplexityElement_initClass()"""
  return _coin.SoComplexityElement_initClass()

def SoComplexityElement_set(*args):
  """
    set(SoState state, SoNode node, float complexity)
    SoComplexityElement_set(SoState state, float complexity)
    """
  return _coin.SoComplexityElement_set(*args)

def SoComplexityElement_get(*args):
  """SoComplexityElement_get(SoState state) -> float"""
  return _coin.SoComplexityElement_get(*args)

def SoComplexityElement_getDefault():
  """SoComplexityElement_getDefault() -> float"""
  return _coin.SoComplexityElement_getDefault()

class SoCoordinateElement(SoReplacedElement):
    """Proxy of C++ SoCoordinateElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoCoordinateElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoCoordinateElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoCoordinateElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoCoordinateElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoCoordinateElement_init(self, *args)

    def set3(*args):
        """set3(SoState state, SoNode node, int32_t numCoords, SbVec3f coords)"""
        return _coin.SoCoordinateElement_set3(*args)

    set3 = staticmethod(set3)
    def set4(*args):
        """set4(SoState state, SoNode node, int32_t numCoords, SbVec4f coords)"""
        return _coin.SoCoordinateElement_set4(*args)

    set4 = staticmethod(set4)
    def getInstance(*args):
        """getInstance(SoState state) -> SoCoordinateElement"""
        return _coin.SoCoordinateElement_getInstance(*args)

    getInstance = staticmethod(getInstance)
    def getNum(self):
        """getNum(self) -> int32_t"""
        return _coin.SoCoordinateElement_getNum(self)

    def is3D(self):
        """is3D(self) -> SbBool"""
        return _coin.SoCoordinateElement_is3D(self)

    def get3(self, *args):
        """get3(self, int index) -> SbVec3f"""
        return _coin.SoCoordinateElement_get3(self, *args)

    def get4(self, *args):
        """get4(self, int index) -> SbVec4f"""
        return _coin.SoCoordinateElement_get4(self, *args)

    def getArrayPtr3(self):
        """getArrayPtr3(self) -> SbVec3f"""
        return _coin.SoCoordinateElement_getArrayPtr3(self)

    def getArrayPtr4(self):
        """getArrayPtr4(self) -> SbVec4f"""
        return _coin.SoCoordinateElement_getArrayPtr4(self)

    def getDefault3():
        """getDefault3() -> SbVec3f"""
        return _coin.SoCoordinateElement_getDefault3()

    getDefault3 = staticmethod(getDefault3)
    def getDefault4():
        """getDefault4() -> SbVec4f"""
        return _coin.SoCoordinateElement_getDefault4()

    getDefault4 = staticmethod(getDefault4)
    def output(self, *args):
        """output(self, FILE file)"""
        return _coin.SoCoordinateElement_output(self, *args)

SoCoordinateElement_swigregister = _coin.SoCoordinateElement_swigregister
SoCoordinateElement_swigregister(SoCoordinateElement)

def SoCoordinateElement_getClassTypeId():
  """SoCoordinateElement_getClassTypeId() -> SoType"""
  return _coin.SoCoordinateElement_getClassTypeId()

def SoCoordinateElement_getClassStackIndex():
  """SoCoordinateElement_getClassStackIndex() -> int"""
  return _coin.SoCoordinateElement_getClassStackIndex()

def SoCoordinateElement_createInstance():
  """SoCoordinateElement_createInstance() -> void"""
  return _coin.SoCoordinateElement_createInstance()

def SoCoordinateElement_initClass():
  """SoCoordinateElement_initClass()"""
  return _coin.SoCoordinateElement_initClass()

def SoCoordinateElement_set3(*args):
  """SoCoordinateElement_set3(SoState state, SoNode node, int32_t numCoords, SbVec3f coords)"""
  return _coin.SoCoordinateElement_set3(*args)

def SoCoordinateElement_set4(*args):
  """SoCoordinateElement_set4(SoState state, SoNode node, int32_t numCoords, SbVec4f coords)"""
  return _coin.SoCoordinateElement_set4(*args)

def SoCoordinateElement_getInstance(*args):
  """SoCoordinateElement_getInstance(SoState state) -> SoCoordinateElement"""
  return _coin.SoCoordinateElement_getInstance(*args)

def SoCoordinateElement_getDefault3():
  """SoCoordinateElement_getDefault3() -> SbVec3f"""
  return _coin.SoCoordinateElement_getDefault3()

def SoCoordinateElement_getDefault4():
  """SoCoordinateElement_getDefault4() -> SbVec4f"""
  return _coin.SoCoordinateElement_getDefault4()

class SoCreaseAngleElement(SoFloatElement):
    """Proxy of C++ SoCreaseAngleElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoCreaseAngleElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoCreaseAngleElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoCreaseAngleElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoCreaseAngleElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoCreaseAngleElement_init(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, float complexity)
        set(SoState state, float complexity)
        """
        return _coin.SoCreaseAngleElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """
        get(SoState state) -> float
        get(SoState state, SbBool isvrml1) -> float
        """
        return _coin.SoCreaseAngleElement_get(*args)

    get = staticmethod(get)
    def getDefault(*args):
        """
        getDefault() -> float
        getDefault(SbBool isvrml1) -> float
        """
        return _coin.SoCreaseAngleElement_getDefault(*args)

    getDefault = staticmethod(getDefault)
SoCreaseAngleElement_swigregister = _coin.SoCreaseAngleElement_swigregister
SoCreaseAngleElement_swigregister(SoCreaseAngleElement)

def SoCreaseAngleElement_getClassTypeId():
  """SoCreaseAngleElement_getClassTypeId() -> SoType"""
  return _coin.SoCreaseAngleElement_getClassTypeId()

def SoCreaseAngleElement_getClassStackIndex():
  """SoCreaseAngleElement_getClassStackIndex() -> int"""
  return _coin.SoCreaseAngleElement_getClassStackIndex()

def SoCreaseAngleElement_createInstance():
  """SoCreaseAngleElement_createInstance() -> void"""
  return _coin.SoCreaseAngleElement_createInstance()

def SoCreaseAngleElement_initClass():
  """SoCreaseAngleElement_initClass()"""
  return _coin.SoCreaseAngleElement_initClass()

def SoCreaseAngleElement_set(*args):
  """
    set(SoState state, SoNode node, float complexity)
    SoCreaseAngleElement_set(SoState state, float complexity)
    """
  return _coin.SoCreaseAngleElement_set(*args)

def SoCreaseAngleElement_get(*args):
  """
    get(SoState state) -> float
    SoCreaseAngleElement_get(SoState state, SbBool isvrml1) -> float
    """
  return _coin.SoCreaseAngleElement_get(*args)

def SoCreaseAngleElement_getDefault(*args):
  """
    getDefault() -> float
    SoCreaseAngleElement_getDefault(SbBool isvrml1) -> float
    """
  return _coin.SoCreaseAngleElement_getDefault(*args)

class SoCullElement(SoElement):
    """Proxy of C++ SoCullElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoCullElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoCullElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoCullElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoCullElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoCullElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoCullElement_push(self, *args)

    def setViewVolume(*args):
        """setViewVolume(SoState state, SbViewVolume vv)"""
        return _coin.SoCullElement_setViewVolume(*args)

    setViewVolume = staticmethod(setViewVolume)
    def addPlane(*args):
        """addPlane(SoState state, SbPlane newplane)"""
        return _coin.SoCullElement_addPlane(*args)

    addPlane = staticmethod(addPlane)
    def cullBox(*args):
        """
        cullBox(SoState state, SbBox3f box, SbBool transform = 1) -> SbBool
        cullBox(SoState state, SbBox3f box) -> SbBool
        """
        return _coin.SoCullElement_cullBox(*args)

    cullBox = staticmethod(cullBox)
    def cullTest(*args):
        """
        cullTest(SoState state, SbBox3f box, SbBool transform = 1) -> SbBool
        cullTest(SoState state, SbBox3f box) -> SbBool
        """
        return _coin.SoCullElement_cullTest(*args)

    cullTest = staticmethod(cullTest)
    def completelyInside(*args):
        """completelyInside(SoState state) -> SbBool"""
        return _coin.SoCullElement_completelyInside(*args)

    completelyInside = staticmethod(completelyInside)
    def matches(self, *args):
        """matches(self, SoElement elt) -> SbBool"""
        return _coin.SoCullElement_matches(self, *args)

    def copyMatchInfo(self):
        """copyMatchInfo(self) -> SoElement"""
        return _coin.SoCullElement_copyMatchInfo(self)

SoCullElement_swigregister = _coin.SoCullElement_swigregister
SoCullElement_swigregister(SoCullElement)

def SoCullElement_getClassTypeId():
  """SoCullElement_getClassTypeId() -> SoType"""
  return _coin.SoCullElement_getClassTypeId()

def SoCullElement_getClassStackIndex():
  """SoCullElement_getClassStackIndex() -> int"""
  return _coin.SoCullElement_getClassStackIndex()

def SoCullElement_createInstance():
  """SoCullElement_createInstance() -> void"""
  return _coin.SoCullElement_createInstance()

def SoCullElement_initClass():
  """SoCullElement_initClass()"""
  return _coin.SoCullElement_initClass()

def SoCullElement_setViewVolume(*args):
  """SoCullElement_setViewVolume(SoState state, SbViewVolume vv)"""
  return _coin.SoCullElement_setViewVolume(*args)

def SoCullElement_addPlane(*args):
  """SoCullElement_addPlane(SoState state, SbPlane newplane)"""
  return _coin.SoCullElement_addPlane(*args)

def SoCullElement_cullBox(*args):
  """
    cullBox(SoState state, SbBox3f box, SbBool transform = 1) -> SbBool
    SoCullElement_cullBox(SoState state, SbBox3f box) -> SbBool
    """
  return _coin.SoCullElement_cullBox(*args)

def SoCullElement_cullTest(*args):
  """
    cullTest(SoState state, SbBox3f box, SbBool transform = 1) -> SbBool
    SoCullElement_cullTest(SoState state, SbBox3f box) -> SbBool
    """
  return _coin.SoCullElement_cullTest(*args)

def SoCullElement_completelyInside(*args):
  """SoCullElement_completelyInside(SoState state) -> SbBool"""
  return _coin.SoCullElement_completelyInside(*args)

class SoDecimationPercentageElement(SoFloatElement):
    """Proxy of C++ SoDecimationPercentageElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoDecimationPercentageElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoDecimationPercentageElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoDecimationPercentageElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoDecimationPercentageElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoDecimationPercentageElement_init(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, float complexity)
        set(SoState state, float complexity)
        """
        return _coin.SoDecimationPercentageElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> float"""
        return _coin.SoDecimationPercentageElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> float"""
        return _coin.SoDecimationPercentageElement_getDefault()

    getDefault = staticmethod(getDefault)
SoDecimationPercentageElement_swigregister = _coin.SoDecimationPercentageElement_swigregister
SoDecimationPercentageElement_swigregister(SoDecimationPercentageElement)

def SoDecimationPercentageElement_getClassTypeId():
  """SoDecimationPercentageElement_getClassTypeId() -> SoType"""
  return _coin.SoDecimationPercentageElement_getClassTypeId()

def SoDecimationPercentageElement_getClassStackIndex():
  """SoDecimationPercentageElement_getClassStackIndex() -> int"""
  return _coin.SoDecimationPercentageElement_getClassStackIndex()

def SoDecimationPercentageElement_createInstance():
  """SoDecimationPercentageElement_createInstance() -> void"""
  return _coin.SoDecimationPercentageElement_createInstance()

def SoDecimationPercentageElement_initClass():
  """SoDecimationPercentageElement_initClass()"""
  return _coin.SoDecimationPercentageElement_initClass()

def SoDecimationPercentageElement_set(*args):
  """
    set(SoState state, SoNode node, float complexity)
    SoDecimationPercentageElement_set(SoState state, float complexity)
    """
  return _coin.SoDecimationPercentageElement_set(*args)

def SoDecimationPercentageElement_get(*args):
  """SoDecimationPercentageElement_get(SoState state) -> float"""
  return _coin.SoDecimationPercentageElement_get(*args)

def SoDecimationPercentageElement_getDefault():
  """SoDecimationPercentageElement_getDefault() -> float"""
  return _coin.SoDecimationPercentageElement_getDefault()

class SoDiffuseColorElement(SoReplacedElement):
    """Proxy of C++ SoDiffuseColorElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoDiffuseColorElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoDiffuseColorElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoDiffuseColorElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoDiffuseColorElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoDiffuseColorElement_init(self, *args)

    def set(*args):
        """set(SoState state, SoNode node, int32_t numcolors, SbColor colors)"""
        return _coin.SoDiffuseColorElement_set(*args)

    set = staticmethod(set)
    def getInstance(*args):
        """getInstance(SoState state) -> SoDiffuseColorElement"""
        return _coin.SoDiffuseColorElement_getInstance(*args)

    getInstance = staticmethod(getInstance)
    def getNum(self):
        """getNum(self) -> int32_t"""
        return _coin.SoDiffuseColorElement_getNum(self)

    def get(self, *args):
        """get(self, int index) -> SbColor"""
        return _coin.SoDiffuseColorElement_get(self, *args)

    def isPacked(self):
        """isPacked(self) -> SbBool"""
        return _coin.SoDiffuseColorElement_isPacked(self)

    def hasPackedTransparency(self):
        """hasPackedTransparency(self) -> SbBool"""
        return _coin.SoDiffuseColorElement_hasPackedTransparency(self)

    def getColorArrayPtr(self):
        """getColorArrayPtr(self) -> SbColor"""
        return _coin.SoDiffuseColorElement_getColorArrayPtr(self)

    def getPackedArrayPtr(self):
        """getPackedArrayPtr(self) -> uint32_t"""
        return _coin.SoDiffuseColorElement_getPackedArrayPtr(self)

SoDiffuseColorElement_swigregister = _coin.SoDiffuseColorElement_swigregister
SoDiffuseColorElement_swigregister(SoDiffuseColorElement)

def SoDiffuseColorElement_getClassTypeId():
  """SoDiffuseColorElement_getClassTypeId() -> SoType"""
  return _coin.SoDiffuseColorElement_getClassTypeId()

def SoDiffuseColorElement_getClassStackIndex():
  """SoDiffuseColorElement_getClassStackIndex() -> int"""
  return _coin.SoDiffuseColorElement_getClassStackIndex()

def SoDiffuseColorElement_createInstance():
  """SoDiffuseColorElement_createInstance() -> void"""
  return _coin.SoDiffuseColorElement_createInstance()

def SoDiffuseColorElement_initClass():
  """SoDiffuseColorElement_initClass()"""
  return _coin.SoDiffuseColorElement_initClass()

def SoDiffuseColorElement_set(*args):
  """SoDiffuseColorElement_set(SoState state, SoNode node, int32_t numcolors, SbColor colors)"""
  return _coin.SoDiffuseColorElement_set(*args)

def SoDiffuseColorElement_getInstance(*args):
  """SoDiffuseColorElement_getInstance(SoState state) -> SoDiffuseColorElement"""
  return _coin.SoDiffuseColorElement_getInstance(*args)

class SoGLClipPlaneElement(SoClipPlaneElement):
    """Proxy of C++ SoGLClipPlaneElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLClipPlaneElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLClipPlaneElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLClipPlaneElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLClipPlaneElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLClipPlaneElement_init(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLClipPlaneElement_pop(self, *args)

    def getMaxGLPlanes():
        """getMaxGLPlanes() -> int"""
        return _coin.SoGLClipPlaneElement_getMaxGLPlanes()

    getMaxGLPlanes = staticmethod(getMaxGLPlanes)
SoGLClipPlaneElement_swigregister = _coin.SoGLClipPlaneElement_swigregister
SoGLClipPlaneElement_swigregister(SoGLClipPlaneElement)

def SoGLClipPlaneElement_getClassTypeId():
  """SoGLClipPlaneElement_getClassTypeId() -> SoType"""
  return _coin.SoGLClipPlaneElement_getClassTypeId()

def SoGLClipPlaneElement_getClassStackIndex():
  """SoGLClipPlaneElement_getClassStackIndex() -> int"""
  return _coin.SoGLClipPlaneElement_getClassStackIndex()

def SoGLClipPlaneElement_createInstance():
  """SoGLClipPlaneElement_createInstance() -> void"""
  return _coin.SoGLClipPlaneElement_createInstance()

def SoGLClipPlaneElement_initClass():
  """SoGLClipPlaneElement_initClass()"""
  return _coin.SoGLClipPlaneElement_initClass()

def SoGLClipPlaneElement_getMaxGLPlanes():
  """SoGLClipPlaneElement_getMaxGLPlanes() -> int"""
  return _coin.SoGLClipPlaneElement_getMaxGLPlanes()

class SoLightElement(SoAccumulatedElement):
    """Proxy of C++ SoLightElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoLightElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoLightElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoLightElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoLightElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoLightElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoLightElement_push(self, *args)

    def add(*args):
        """add(SoState state, SoLight light)"""
        return _coin.SoLightElement_add(*args)

    add = staticmethod(add)
    def getLights(*args):
        """getLights(SoState state) -> SoNodeList"""
        return _coin.SoLightElement_getLights(*args)

    getLights = staticmethod(getLights)
    def getMatrix(*args):
        """getMatrix(SoState state, int index) -> SbMatrix"""
        return _coin.SoLightElement_getMatrix(*args)

    getMatrix = staticmethod(getMatrix)
SoLightElement_swigregister = _coin.SoLightElement_swigregister
SoLightElement_swigregister(SoLightElement)

def SoLightElement_getClassTypeId():
  """SoLightElement_getClassTypeId() -> SoType"""
  return _coin.SoLightElement_getClassTypeId()

def SoLightElement_getClassStackIndex():
  """SoLightElement_getClassStackIndex() -> int"""
  return _coin.SoLightElement_getClassStackIndex()

def SoLightElement_createInstance():
  """SoLightElement_createInstance() -> void"""
  return _coin.SoLightElement_createInstance()

def SoLightElement_initClass():
  """SoLightElement_initClass()"""
  return _coin.SoLightElement_initClass()

def SoLightElement_add(*args):
  """SoLightElement_add(SoState state, SoLight light)"""
  return _coin.SoLightElement_add(*args)

def SoLightElement_getLights(*args):
  """SoLightElement_getLights(SoState state) -> SoNodeList"""
  return _coin.SoLightElement_getLights(*args)

def SoLightElement_getMatrix(*args):
  """SoLightElement_getMatrix(SoState state, int index) -> SbMatrix"""
  return _coin.SoLightElement_getMatrix(*args)

class SoGLModelMatrixElement(SoModelMatrixElement):
    """Proxy of C++ SoGLModelMatrixElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLModelMatrixElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLModelMatrixElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLModelMatrixElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLModelMatrixElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLModelMatrixElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoGLModelMatrixElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLModelMatrixElement_pop(self, *args)

SoGLModelMatrixElement_swigregister = _coin.SoGLModelMatrixElement_swigregister
SoGLModelMatrixElement_swigregister(SoGLModelMatrixElement)

def SoGLModelMatrixElement_getClassTypeId():
  """SoGLModelMatrixElement_getClassTypeId() -> SoType"""
  return _coin.SoGLModelMatrixElement_getClassTypeId()

def SoGLModelMatrixElement_getClassStackIndex():
  """SoGLModelMatrixElement_getClassStackIndex() -> int"""
  return _coin.SoGLModelMatrixElement_getClassStackIndex()

def SoGLModelMatrixElement_createInstance():
  """SoGLModelMatrixElement_createInstance() -> void"""
  return _coin.SoGLModelMatrixElement_createInstance()

def SoGLModelMatrixElement_initClass():
  """SoGLModelMatrixElement_initClass()"""
  return _coin.SoGLModelMatrixElement_initClass()

class SoProfileElement(SoAccumulatedElement):
    """Proxy of C++ SoProfileElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoProfileElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoProfileElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoProfileElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoProfileElement_initClass()

    initClass = staticmethod(initClass)
    START_FIRST = _coin.SoProfileElement_START_FIRST
    START_NEW = _coin.SoProfileElement_START_NEW
    ADD_TO_CURRENT = _coin.SoProfileElement_ADD_TO_CURRENT
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoProfileElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoProfileElement_push(self, *args)

    def add(*args):
        """add(SoState state, SoProfile profile)"""
        return _coin.SoProfileElement_add(*args)

    add = staticmethod(add)
    def get(*args):
        """get(SoState state) -> SoNodeList"""
        return _coin.SoProfileElement_get(*args)

    get = staticmethod(get)
SoProfileElement_swigregister = _coin.SoProfileElement_swigregister
SoProfileElement_swigregister(SoProfileElement)

def SoProfileElement_getClassTypeId():
  """SoProfileElement_getClassTypeId() -> SoType"""
  return _coin.SoProfileElement_getClassTypeId()

def SoProfileElement_getClassStackIndex():
  """SoProfileElement_getClassStackIndex() -> int"""
  return _coin.SoProfileElement_getClassStackIndex()

def SoProfileElement_createInstance():
  """SoProfileElement_createInstance() -> void"""
  return _coin.SoProfileElement_createInstance()

def SoProfileElement_initClass():
  """SoProfileElement_initClass()"""
  return _coin.SoProfileElement_initClass()

def SoProfileElement_add(*args):
  """SoProfileElement_add(SoState state, SoProfile profile)"""
  return _coin.SoProfileElement_add(*args)

def SoProfileElement_get(*args):
  """SoProfileElement_get(SoState state) -> SoNodeList"""
  return _coin.SoProfileElement_get(*args)

class SoTextureMatrixElement(SoAccumulatedElement):
    """Proxy of C++ SoTextureMatrixElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextureMatrixElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoTextureMatrixElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoTextureMatrixElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoTextureMatrixElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoTextureMatrixElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoTextureMatrixElement_push(self, *args)

    def makeIdentity(*args):
        """makeIdentity(SoState state, SoNode node)"""
        return _coin.SoTextureMatrixElement_makeIdentity(*args)

    makeIdentity = staticmethod(makeIdentity)
    def set(*args):
        """set(SoState state, SoNode node)"""
        return _coin.SoTextureMatrixElement_set(*args)

    set = staticmethod(set)
    def mult(*args):
        """mult(SoState state, SoNode node)"""
        return _coin.SoTextureMatrixElement_mult(*args)

    mult = staticmethod(mult)
    def translateBy(*args):
        """translateBy(SoState state, SoNode node, SbVec3f translation)"""
        return _coin.SoTextureMatrixElement_translateBy(*args)

    translateBy = staticmethod(translateBy)
    def rotateBy(*args):
        """rotateBy(SoState state, SoNode node, SbRotation rotation)"""
        return _coin.SoTextureMatrixElement_rotateBy(*args)

    rotateBy = staticmethod(rotateBy)
    def scaleBy(*args):
        """scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"""
        return _coin.SoTextureMatrixElement_scaleBy(*args)

    scaleBy = staticmethod(scaleBy)
    def get(*args):
        """get(SoState state) -> SbMatrix"""
        return _coin.SoTextureMatrixElement_get(*args)

    get = staticmethod(get)
    def emptyMatrix(*args):
        """emptyMatrix(SoState state)"""
        return _coin.SoTextureMatrixElement_emptyMatrix(*args)

    emptyMatrix = staticmethod(emptyMatrix)
SoTextureMatrixElement_swigregister = _coin.SoTextureMatrixElement_swigregister
SoTextureMatrixElement_swigregister(SoTextureMatrixElement)

def SoTextureMatrixElement_getClassTypeId():
  """SoTextureMatrixElement_getClassTypeId() -> SoType"""
  return _coin.SoTextureMatrixElement_getClassTypeId()

def SoTextureMatrixElement_getClassStackIndex():
  """SoTextureMatrixElement_getClassStackIndex() -> int"""
  return _coin.SoTextureMatrixElement_getClassStackIndex()

def SoTextureMatrixElement_createInstance():
  """SoTextureMatrixElement_createInstance() -> void"""
  return _coin.SoTextureMatrixElement_createInstance()

def SoTextureMatrixElement_initClass():
  """SoTextureMatrixElement_initClass()"""
  return _coin.SoTextureMatrixElement_initClass()

def SoTextureMatrixElement_makeIdentity(*args):
  """SoTextureMatrixElement_makeIdentity(SoState state, SoNode node)"""
  return _coin.SoTextureMatrixElement_makeIdentity(*args)

def SoTextureMatrixElement_set(*args):
  """SoTextureMatrixElement_set(SoState state, SoNode node)"""
  return _coin.SoTextureMatrixElement_set(*args)

def SoTextureMatrixElement_mult(*args):
  """SoTextureMatrixElement_mult(SoState state, SoNode node)"""
  return _coin.SoTextureMatrixElement_mult(*args)

def SoTextureMatrixElement_translateBy(*args):
  """SoTextureMatrixElement_translateBy(SoState state, SoNode node, SbVec3f translation)"""
  return _coin.SoTextureMatrixElement_translateBy(*args)

def SoTextureMatrixElement_rotateBy(*args):
  """SoTextureMatrixElement_rotateBy(SoState state, SoNode node, SbRotation rotation)"""
  return _coin.SoTextureMatrixElement_rotateBy(*args)

def SoTextureMatrixElement_scaleBy(*args):
  """SoTextureMatrixElement_scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"""
  return _coin.SoTextureMatrixElement_scaleBy(*args)

def SoTextureMatrixElement_get(*args):
  """SoTextureMatrixElement_get(SoState state) -> SbMatrix"""
  return _coin.SoTextureMatrixElement_get(*args)

def SoTextureMatrixElement_emptyMatrix(*args):
  """SoTextureMatrixElement_emptyMatrix(SoState state)"""
  return _coin.SoTextureMatrixElement_emptyMatrix(*args)

class SoGLTextureMatrixElement(SoTextureMatrixElement):
    """Proxy of C++ SoGLTextureMatrixElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLTextureMatrixElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLTextureMatrixElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLTextureMatrixElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLTextureMatrixElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLTextureMatrixElement_init(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLTextureMatrixElement_pop(self, *args)

    def setEltIdentity():
        """setEltIdentity()"""
        return _coin.SoGLTextureMatrixElement_setEltIdentity()

    setEltIdentity = staticmethod(setEltIdentity)
    def setElt(self):
        """setElt(self)"""
        return _coin.SoGLTextureMatrixElement_setElt(self)

    def makeEltIdentity(self):
        """makeEltIdentity(self)"""
        return _coin.SoGLTextureMatrixElement_makeEltIdentity(self)

    def multElt(self):
        """multElt(self)"""
        return _coin.SoGLTextureMatrixElement_multElt(self)

    def translateEltBy(self, *args):
        """translateEltBy(self, SbVec3f translation)"""
        return _coin.SoGLTextureMatrixElement_translateEltBy(self, *args)

    def rotateEltBy(self, *args):
        """rotateEltBy(self, SbRotation translation)"""
        return _coin.SoGLTextureMatrixElement_rotateEltBy(self, *args)

    def scaleEltBy(self, *args):
        """scaleEltBy(self, SbVec3f scaleFactor)"""
        return _coin.SoGLTextureMatrixElement_scaleEltBy(self, *args)

SoGLTextureMatrixElement_swigregister = _coin.SoGLTextureMatrixElement_swigregister
SoGLTextureMatrixElement_swigregister(SoGLTextureMatrixElement)

def SoGLTextureMatrixElement_getClassTypeId():
  """SoGLTextureMatrixElement_getClassTypeId() -> SoType"""
  return _coin.SoGLTextureMatrixElement_getClassTypeId()

def SoGLTextureMatrixElement_getClassStackIndex():
  """SoGLTextureMatrixElement_getClassStackIndex() -> int"""
  return _coin.SoGLTextureMatrixElement_getClassStackIndex()

def SoGLTextureMatrixElement_createInstance():
  """SoGLTextureMatrixElement_createInstance() -> void"""
  return _coin.SoGLTextureMatrixElement_createInstance()

def SoGLTextureMatrixElement_initClass():
  """SoGLTextureMatrixElement_initClass()"""
  return _coin.SoGLTextureMatrixElement_initClass()

def SoGLTextureMatrixElement_setEltIdentity():
  """SoGLTextureMatrixElement_setEltIdentity()"""
  return _coin.SoGLTextureMatrixElement_setEltIdentity()

class SoGLDrawStyleElement(SoDrawStyleElement):
    """Proxy of C++ SoGLDrawStyleElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLDrawStyleElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLDrawStyleElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLDrawStyleElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLDrawStyleElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLDrawStyleElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoGLDrawStyleElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLDrawStyleElement_pop(self, *args)

SoGLDrawStyleElement_swigregister = _coin.SoGLDrawStyleElement_swigregister
SoGLDrawStyleElement_swigregister(SoGLDrawStyleElement)

def SoGLDrawStyleElement_getClassTypeId():
  """SoGLDrawStyleElement_getClassTypeId() -> SoType"""
  return _coin.SoGLDrawStyleElement_getClassTypeId()

def SoGLDrawStyleElement_getClassStackIndex():
  """SoGLDrawStyleElement_getClassStackIndex() -> int"""
  return _coin.SoGLDrawStyleElement_getClassStackIndex()

def SoGLDrawStyleElement_createInstance():
  """SoGLDrawStyleElement_createInstance() -> void"""
  return _coin.SoGLDrawStyleElement_createInstance()

def SoGLDrawStyleElement_initClass():
  """SoGLDrawStyleElement_initClass()"""
  return _coin.SoGLDrawStyleElement_initClass()

class SoGLLightIdElement(SoInt32Element):
    """Proxy of C++ SoGLLightIdElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLLightIdElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLLightIdElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLLightIdElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLLightIdElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLLightIdElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoGLLightIdElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLLightIdElement_pop(self, *args)

    def increment(*args):
        """
        increment(SoState state, SoNode node) -> int32_t
        increment(SoState state) -> int32_t
        """
        return _coin.SoGLLightIdElement_increment(*args)

    increment = staticmethod(increment)
    def get(*args):
        """get(SoState state) -> int32_t"""
        return _coin.SoGLLightIdElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> int32_t"""
        return _coin.SoGLLightIdElement_getDefault()

    getDefault = staticmethod(getDefault)
    def getMaxGLSources():
        """getMaxGLSources() -> int32_t"""
        return _coin.SoGLLightIdElement_getMaxGLSources()

    getMaxGLSources = staticmethod(getMaxGLSources)
SoGLLightIdElement_swigregister = _coin.SoGLLightIdElement_swigregister
SoGLLightIdElement_swigregister(SoGLLightIdElement)

def SoGLLightIdElement_getClassTypeId():
  """SoGLLightIdElement_getClassTypeId() -> SoType"""
  return _coin.SoGLLightIdElement_getClassTypeId()

def SoGLLightIdElement_getClassStackIndex():
  """SoGLLightIdElement_getClassStackIndex() -> int"""
  return _coin.SoGLLightIdElement_getClassStackIndex()

def SoGLLightIdElement_createInstance():
  """SoGLLightIdElement_createInstance() -> void"""
  return _coin.SoGLLightIdElement_createInstance()

def SoGLLightIdElement_initClass():
  """SoGLLightIdElement_initClass()"""
  return _coin.SoGLLightIdElement_initClass()

def SoGLLightIdElement_increment(*args):
  """
    increment(SoState state, SoNode node) -> int32_t
    SoGLLightIdElement_increment(SoState state) -> int32_t
    """
  return _coin.SoGLLightIdElement_increment(*args)

def SoGLLightIdElement_get(*args):
  """SoGLLightIdElement_get(SoState state) -> int32_t"""
  return _coin.SoGLLightIdElement_get(*args)

def SoGLLightIdElement_getDefault():
  """SoGLLightIdElement_getDefault() -> int32_t"""
  return _coin.SoGLLightIdElement_getDefault()

def SoGLLightIdElement_getMaxGLSources():
  """SoGLLightIdElement_getMaxGLSources() -> int32_t"""
  return _coin.SoGLLightIdElement_getMaxGLSources()

class SoTextureEnabledElement(SoInt32Element):
    """Proxy of C++ SoTextureEnabledElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextureEnabledElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoTextureEnabledElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoTextureEnabledElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoTextureEnabledElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoTextureEnabledElement_init(self, *args)

    def set(*args):
        """set(SoState state, SoNode node, SbBool enabled)"""
        return _coin.SoTextureEnabledElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> SbBool"""
        return _coin.SoTextureEnabledElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> SbBool"""
        return _coin.SoTextureEnabledElement_getDefault()

    getDefault = staticmethod(getDefault)
    def setElt(self, *args):
        """setElt(self, int32_t value)"""
        return _coin.SoTextureEnabledElement_setElt(self, *args)

SoTextureEnabledElement_swigregister = _coin.SoTextureEnabledElement_swigregister
SoTextureEnabledElement_swigregister(SoTextureEnabledElement)

def SoTextureEnabledElement_getClassTypeId():
  """SoTextureEnabledElement_getClassTypeId() -> SoType"""
  return _coin.SoTextureEnabledElement_getClassTypeId()

def SoTextureEnabledElement_getClassStackIndex():
  """SoTextureEnabledElement_getClassStackIndex() -> int"""
  return _coin.SoTextureEnabledElement_getClassStackIndex()

def SoTextureEnabledElement_createInstance():
  """SoTextureEnabledElement_createInstance() -> void"""
  return _coin.SoTextureEnabledElement_createInstance()

def SoTextureEnabledElement_initClass():
  """SoTextureEnabledElement_initClass()"""
  return _coin.SoTextureEnabledElement_initClass()

def SoTextureEnabledElement_set(*args):
  """SoTextureEnabledElement_set(SoState state, SoNode node, SbBool enabled)"""
  return _coin.SoTextureEnabledElement_set(*args)

def SoTextureEnabledElement_get(*args):
  """SoTextureEnabledElement_get(SoState state) -> SbBool"""
  return _coin.SoTextureEnabledElement_get(*args)

def SoTextureEnabledElement_getDefault():
  """SoTextureEnabledElement_getDefault() -> SbBool"""
  return _coin.SoTextureEnabledElement_getDefault()

class SoGLTextureEnabledElement(SoTextureEnabledElement):
    """Proxy of C++ SoGLTextureEnabledElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLTextureEnabledElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLTextureEnabledElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLTextureEnabledElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLTextureEnabledElement_initClass()

    initClass = staticmethod(initClass)
    DISABLED = _coin.SoGLTextureEnabledElement_DISABLED
    TEXTURE2D = _coin.SoGLTextureEnabledElement_TEXTURE2D
    RECTANGLE = _coin.SoGLTextureEnabledElement_RECTANGLE
    CUBEMAP = _coin.SoGLTextureEnabledElement_CUBEMAP
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLTextureEnabledElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoGLTextureEnabledElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLTextureEnabledElement_pop(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, SbBool enabled)
        set(SoState state, SbBool enabled)
        """
        return _coin.SoGLTextureEnabledElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> SbBool"""
        return _coin.SoGLTextureEnabledElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> SbBool"""
        return _coin.SoGLTextureEnabledElement_getDefault()

    getDefault = staticmethod(getDefault)
    def setElt(self, *args):
        """setElt(self, int32_t value)"""
        return _coin.SoGLTextureEnabledElement_setElt(self, *args)

    def enableRectangle(*args):
        """enableRectangle(SoState state, SoNode node)"""
        return _coin.SoGLTextureEnabledElement_enableRectangle(*args)

    enableRectangle = staticmethod(enableRectangle)
    def enableCubeMap(*args):
        """enableCubeMap(SoState state, SoNode node)"""
        return _coin.SoGLTextureEnabledElement_enableCubeMap(*args)

    enableCubeMap = staticmethod(enableCubeMap)
    def getMode(*args):
        """getMode(SoState state) -> Mode"""
        return _coin.SoGLTextureEnabledElement_getMode(*args)

    getMode = staticmethod(getMode)
SoGLTextureEnabledElement_swigregister = _coin.SoGLTextureEnabledElement_swigregister
SoGLTextureEnabledElement_swigregister(SoGLTextureEnabledElement)

def SoGLTextureEnabledElement_getClassTypeId():
  """SoGLTextureEnabledElement_getClassTypeId() -> SoType"""
  return _coin.SoGLTextureEnabledElement_getClassTypeId()

def SoGLTextureEnabledElement_getClassStackIndex():
  """SoGLTextureEnabledElement_getClassStackIndex() -> int"""
  return _coin.SoGLTextureEnabledElement_getClassStackIndex()

def SoGLTextureEnabledElement_createInstance():
  """SoGLTextureEnabledElement_createInstance() -> void"""
  return _coin.SoGLTextureEnabledElement_createInstance()

def SoGLTextureEnabledElement_initClass():
  """SoGLTextureEnabledElement_initClass()"""
  return _coin.SoGLTextureEnabledElement_initClass()

def SoGLTextureEnabledElement_set(*args):
  """
    set(SoState state, SoNode node, SbBool enabled)
    SoGLTextureEnabledElement_set(SoState state, SbBool enabled)
    """
  return _coin.SoGLTextureEnabledElement_set(*args)

def SoGLTextureEnabledElement_get(*args):
  """SoGLTextureEnabledElement_get(SoState state) -> SbBool"""
  return _coin.SoGLTextureEnabledElement_get(*args)

def SoGLTextureEnabledElement_getDefault():
  """SoGLTextureEnabledElement_getDefault() -> SbBool"""
  return _coin.SoGLTextureEnabledElement_getDefault()

def SoGLTextureEnabledElement_enableRectangle(*args):
  """SoGLTextureEnabledElement_enableRectangle(SoState state, SoNode node)"""
  return _coin.SoGLTextureEnabledElement_enableRectangle(*args)

def SoGLTextureEnabledElement_enableCubeMap(*args):
  """SoGLTextureEnabledElement_enableCubeMap(SoState state, SoNode node)"""
  return _coin.SoGLTextureEnabledElement_enableCubeMap(*args)

def SoGLTextureEnabledElement_getMode(*args):
  """SoGLTextureEnabledElement_getMode(SoState state) -> Mode"""
  return _coin.SoGLTextureEnabledElement_getMode(*args)

class SoTexture3EnabledElement(SoInt32Element):
    """Proxy of C++ SoTexture3EnabledElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTexture3EnabledElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoTexture3EnabledElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoTexture3EnabledElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoTexture3EnabledElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoTexture3EnabledElement_init(self, *args)

    def set(*args):
        """set(SoState state, SoNode node, SbBool enabled)"""
        return _coin.SoTexture3EnabledElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> SbBool"""
        return _coin.SoTexture3EnabledElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> SbBool"""
        return _coin.SoTexture3EnabledElement_getDefault()

    getDefault = staticmethod(getDefault)
    def setElt(self, *args):
        """setElt(self, int32_t value)"""
        return _coin.SoTexture3EnabledElement_setElt(self, *args)

SoTexture3EnabledElement_swigregister = _coin.SoTexture3EnabledElement_swigregister
SoTexture3EnabledElement_swigregister(SoTexture3EnabledElement)

def SoTexture3EnabledElement_getClassTypeId():
  """SoTexture3EnabledElement_getClassTypeId() -> SoType"""
  return _coin.SoTexture3EnabledElement_getClassTypeId()

def SoTexture3EnabledElement_getClassStackIndex():
  """SoTexture3EnabledElement_getClassStackIndex() -> int"""
  return _coin.SoTexture3EnabledElement_getClassStackIndex()

def SoTexture3EnabledElement_createInstance():
  """SoTexture3EnabledElement_createInstance() -> void"""
  return _coin.SoTexture3EnabledElement_createInstance()

def SoTexture3EnabledElement_initClass():
  """SoTexture3EnabledElement_initClass()"""
  return _coin.SoTexture3EnabledElement_initClass()

def SoTexture3EnabledElement_set(*args):
  """SoTexture3EnabledElement_set(SoState state, SoNode node, SbBool enabled)"""
  return _coin.SoTexture3EnabledElement_set(*args)

def SoTexture3EnabledElement_get(*args):
  """SoTexture3EnabledElement_get(SoState state) -> SbBool"""
  return _coin.SoTexture3EnabledElement_get(*args)

def SoTexture3EnabledElement_getDefault():
  """SoTexture3EnabledElement_getDefault() -> SbBool"""
  return _coin.SoTexture3EnabledElement_getDefault()

class SoGLTexture3EnabledElement(SoTexture3EnabledElement):
    """Proxy of C++ SoGLTexture3EnabledElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLTexture3EnabledElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLTexture3EnabledElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLTexture3EnabledElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLTexture3EnabledElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLTexture3EnabledElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoGLTexture3EnabledElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLTexture3EnabledElement_pop(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, SbBool enabled)
        set(SoState state, SbBool enabled)
        """
        return _coin.SoGLTexture3EnabledElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> SbBool"""
        return _coin.SoGLTexture3EnabledElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> SbBool"""
        return _coin.SoGLTexture3EnabledElement_getDefault()

    getDefault = staticmethod(getDefault)
    def setElt(self, *args):
        """setElt(self, int32_t value)"""
        return _coin.SoGLTexture3EnabledElement_setElt(self, *args)

SoGLTexture3EnabledElement_swigregister = _coin.SoGLTexture3EnabledElement_swigregister
SoGLTexture3EnabledElement_swigregister(SoGLTexture3EnabledElement)

def SoGLTexture3EnabledElement_getClassTypeId():
  """SoGLTexture3EnabledElement_getClassTypeId() -> SoType"""
  return _coin.SoGLTexture3EnabledElement_getClassTypeId()

def SoGLTexture3EnabledElement_getClassStackIndex():
  """SoGLTexture3EnabledElement_getClassStackIndex() -> int"""
  return _coin.SoGLTexture3EnabledElement_getClassStackIndex()

def SoGLTexture3EnabledElement_createInstance():
  """SoGLTexture3EnabledElement_createInstance() -> void"""
  return _coin.SoGLTexture3EnabledElement_createInstance()

def SoGLTexture3EnabledElement_initClass():
  """SoGLTexture3EnabledElement_initClass()"""
  return _coin.SoGLTexture3EnabledElement_initClass()

def SoGLTexture3EnabledElement_set(*args):
  """
    set(SoState state, SoNode node, SbBool enabled)
    SoGLTexture3EnabledElement_set(SoState state, SbBool enabled)
    """
  return _coin.SoGLTexture3EnabledElement_set(*args)

def SoGLTexture3EnabledElement_get(*args):
  """SoGLTexture3EnabledElement_get(SoState state) -> SbBool"""
  return _coin.SoGLTexture3EnabledElement_get(*args)

def SoGLTexture3EnabledElement_getDefault():
  """SoGLTexture3EnabledElement_getDefault() -> SbBool"""
  return _coin.SoGLTexture3EnabledElement_getDefault()

class SoLinePatternElement(SoInt32Element):
    """Proxy of C++ SoLinePatternElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoLinePatternElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoLinePatternElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoLinePatternElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoLinePatternElement_initClass()

    initClass = staticmethod(initClass)
    CONTINUOUS = _coin.SoLinePatternElement_CONTINUOUS
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoLinePatternElement_init(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, int32_t pattern)
        set(SoState state, int32_t pattern)
        """
        return _coin.SoLinePatternElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> int32_t"""
        return _coin.SoLinePatternElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> int32_t"""
        return _coin.SoLinePatternElement_getDefault()

    getDefault = staticmethod(getDefault)
SoLinePatternElement_swigregister = _coin.SoLinePatternElement_swigregister
SoLinePatternElement_swigregister(SoLinePatternElement)

def SoLinePatternElement_getClassTypeId():
  """SoLinePatternElement_getClassTypeId() -> SoType"""
  return _coin.SoLinePatternElement_getClassTypeId()

def SoLinePatternElement_getClassStackIndex():
  """SoLinePatternElement_getClassStackIndex() -> int"""
  return _coin.SoLinePatternElement_getClassStackIndex()

def SoLinePatternElement_createInstance():
  """SoLinePatternElement_createInstance() -> void"""
  return _coin.SoLinePatternElement_createInstance()

def SoLinePatternElement_initClass():
  """SoLinePatternElement_initClass()"""
  return _coin.SoLinePatternElement_initClass()

def SoLinePatternElement_set(*args):
  """
    set(SoState state, SoNode node, int32_t pattern)
    SoLinePatternElement_set(SoState state, int32_t pattern)
    """
  return _coin.SoLinePatternElement_set(*args)

def SoLinePatternElement_get(*args):
  """SoLinePatternElement_get(SoState state) -> int32_t"""
  return _coin.SoLinePatternElement_get(*args)

def SoLinePatternElement_getDefault():
  """SoLinePatternElement_getDefault() -> int32_t"""
  return _coin.SoLinePatternElement_getDefault()

class SoGLLinePatternElement(SoLinePatternElement):
    """Proxy of C++ SoGLLinePatternElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLLinePatternElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLLinePatternElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLLinePatternElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLLinePatternElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLLinePatternElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoGLLinePatternElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLLinePatternElement_pop(self, *args)

SoGLLinePatternElement_swigregister = _coin.SoGLLinePatternElement_swigregister
SoGLLinePatternElement_swigregister(SoGLLinePatternElement)

def SoGLLinePatternElement_getClassTypeId():
  """SoGLLinePatternElement_getClassTypeId() -> SoType"""
  return _coin.SoGLLinePatternElement_getClassTypeId()

def SoGLLinePatternElement_getClassStackIndex():
  """SoGLLinePatternElement_getClassStackIndex() -> int"""
  return _coin.SoGLLinePatternElement_getClassStackIndex()

def SoGLLinePatternElement_createInstance():
  """SoGLLinePatternElement_createInstance() -> void"""
  return _coin.SoGLLinePatternElement_createInstance()

def SoGLLinePatternElement_initClass():
  """SoGLLinePatternElement_initClass()"""
  return _coin.SoGLLinePatternElement_initClass()

class SoSwitchElement(SoInt32Element):
    """Proxy of C++ SoSwitchElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSwitchElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoSwitchElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSwitchElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoSwitchElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoSwitchElement_init(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, int32_t index)
        set(SoState state, int32_t index)
        """
        return _coin.SoSwitchElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> int32_t"""
        return _coin.SoSwitchElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> int32_t"""
        return _coin.SoSwitchElement_getDefault()

    getDefault = staticmethod(getDefault)
SoSwitchElement_swigregister = _coin.SoSwitchElement_swigregister
SoSwitchElement_swigregister(SoSwitchElement)

def SoSwitchElement_getClassTypeId():
  """SoSwitchElement_getClassTypeId() -> SoType"""
  return _coin.SoSwitchElement_getClassTypeId()

def SoSwitchElement_getClassStackIndex():
  """SoSwitchElement_getClassStackIndex() -> int"""
  return _coin.SoSwitchElement_getClassStackIndex()

def SoSwitchElement_createInstance():
  """SoSwitchElement_createInstance() -> void"""
  return _coin.SoSwitchElement_createInstance()

def SoSwitchElement_initClass():
  """SoSwitchElement_initClass()"""
  return _coin.SoSwitchElement_initClass()

def SoSwitchElement_set(*args):
  """
    set(SoState state, SoNode node, int32_t index)
    SoSwitchElement_set(SoState state, int32_t index)
    """
  return _coin.SoSwitchElement_set(*args)

def SoSwitchElement_get(*args):
  """SoSwitchElement_get(SoState state) -> int32_t"""
  return _coin.SoSwitchElement_get(*args)

def SoSwitchElement_getDefault():
  """SoSwitchElement_getDefault() -> int32_t"""
  return _coin.SoSwitchElement_getDefault()

class SoTextOutlineEnabledElement(SoInt32Element):
    """Proxy of C++ SoTextOutlineEnabledElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextOutlineEnabledElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoTextOutlineEnabledElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoTextOutlineEnabledElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoTextOutlineEnabledElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoTextOutlineEnabledElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoTextOutlineEnabledElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoTextOutlineEnabledElement_pop(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, SbBool enabled)
        set(SoState state, SbBool enabled)
        """
        return _coin.SoTextOutlineEnabledElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> SbBool"""
        return _coin.SoTextOutlineEnabledElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> SbBool"""
        return _coin.SoTextOutlineEnabledElement_getDefault()

    getDefault = staticmethod(getDefault)
SoTextOutlineEnabledElement_swigregister = _coin.SoTextOutlineEnabledElement_swigregister
SoTextOutlineEnabledElement_swigregister(SoTextOutlineEnabledElement)

def SoTextOutlineEnabledElement_getClassTypeId():
  """SoTextOutlineEnabledElement_getClassTypeId() -> SoType"""
  return _coin.SoTextOutlineEnabledElement_getClassTypeId()

def SoTextOutlineEnabledElement_getClassStackIndex():
  """SoTextOutlineEnabledElement_getClassStackIndex() -> int"""
  return _coin.SoTextOutlineEnabledElement_getClassStackIndex()

def SoTextOutlineEnabledElement_createInstance():
  """SoTextOutlineEnabledElement_createInstance() -> void"""
  return _coin.SoTextOutlineEnabledElement_createInstance()

def SoTextOutlineEnabledElement_initClass():
  """SoTextOutlineEnabledElement_initClass()"""
  return _coin.SoTextOutlineEnabledElement_initClass()

def SoTextOutlineEnabledElement_set(*args):
  """
    set(SoState state, SoNode node, SbBool enabled)
    SoTextOutlineEnabledElement_set(SoState state, SbBool enabled)
    """
  return _coin.SoTextOutlineEnabledElement_set(*args)

def SoTextOutlineEnabledElement_get(*args):
  """SoTextOutlineEnabledElement_get(SoState state) -> SbBool"""
  return _coin.SoTextOutlineEnabledElement_get(*args)

def SoTextOutlineEnabledElement_getDefault():
  """SoTextOutlineEnabledElement_getDefault() -> SbBool"""
  return _coin.SoTextOutlineEnabledElement_getDefault()

class SoUnitsElement(SoInt32Element):
    """Proxy of C++ SoUnitsElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoUnitsElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoUnitsElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoUnitsElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoUnitsElement_initClass()

    initClass = staticmethod(initClass)
    METERS = _coin.SoUnitsElement_METERS
    CENTIMETERS = _coin.SoUnitsElement_CENTIMETERS
    MILLIMETERS = _coin.SoUnitsElement_MILLIMETERS
    MICROMETERS = _coin.SoUnitsElement_MICROMETERS
    MICRONS = _coin.SoUnitsElement_MICRONS
    NANOMETERS = _coin.SoUnitsElement_NANOMETERS
    ANGSTROMS = _coin.SoUnitsElement_ANGSTROMS
    KILOMETERS = _coin.SoUnitsElement_KILOMETERS
    FEET = _coin.SoUnitsElement_FEET
    INCHES = _coin.SoUnitsElement_INCHES
    POINTS = _coin.SoUnitsElement_POINTS
    YARDS = _coin.SoUnitsElement_YARDS
    MILES = _coin.SoUnitsElement_MILES
    NAUTICAL_MILES = _coin.SoUnitsElement_NAUTICAL_MILES
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoUnitsElement_init(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, Units units)
        set(SoState state, Units units)
        """
        return _coin.SoUnitsElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> Units"""
        return _coin.SoUnitsElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> Units"""
        return _coin.SoUnitsElement_getDefault()

    getDefault = staticmethod(getDefault)
SoUnitsElement_swigregister = _coin.SoUnitsElement_swigregister
SoUnitsElement_swigregister(SoUnitsElement)

def SoUnitsElement_getClassTypeId():
  """SoUnitsElement_getClassTypeId() -> SoType"""
  return _coin.SoUnitsElement_getClassTypeId()

def SoUnitsElement_getClassStackIndex():
  """SoUnitsElement_getClassStackIndex() -> int"""
  return _coin.SoUnitsElement_getClassStackIndex()

def SoUnitsElement_createInstance():
  """SoUnitsElement_createInstance() -> void"""
  return _coin.SoUnitsElement_createInstance()

def SoUnitsElement_initClass():
  """SoUnitsElement_initClass()"""
  return _coin.SoUnitsElement_initClass()

def SoUnitsElement_set(*args):
  """
    set(SoState state, SoNode node, Units units)
    SoUnitsElement_set(SoState state, Units units)
    """
  return _coin.SoUnitsElement_set(*args)

def SoUnitsElement_get(*args):
  """SoUnitsElement_get(SoState state) -> Units"""
  return _coin.SoUnitsElement_get(*args)

def SoUnitsElement_getDefault():
  """SoUnitsElement_getDefault() -> Units"""
  return _coin.SoUnitsElement_getDefault()

class SoFocalDistanceElement(SoFloatElement):
    """Proxy of C++ SoFocalDistanceElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoFocalDistanceElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoFocalDistanceElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoFocalDistanceElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoFocalDistanceElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoFocalDistanceElement_init(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, float distance)
        set(SoState state, float distance)
        """
        return _coin.SoFocalDistanceElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> float"""
        return _coin.SoFocalDistanceElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> float"""
        return _coin.SoFocalDistanceElement_getDefault()

    getDefault = staticmethod(getDefault)
SoFocalDistanceElement_swigregister = _coin.SoFocalDistanceElement_swigregister
SoFocalDistanceElement_swigregister(SoFocalDistanceElement)

def SoFocalDistanceElement_getClassTypeId():
  """SoFocalDistanceElement_getClassTypeId() -> SoType"""
  return _coin.SoFocalDistanceElement_getClassTypeId()

def SoFocalDistanceElement_getClassStackIndex():
  """SoFocalDistanceElement_getClassStackIndex() -> int"""
  return _coin.SoFocalDistanceElement_getClassStackIndex()

def SoFocalDistanceElement_createInstance():
  """SoFocalDistanceElement_createInstance() -> void"""
  return _coin.SoFocalDistanceElement_createInstance()

def SoFocalDistanceElement_initClass():
  """SoFocalDistanceElement_initClass()"""
  return _coin.SoFocalDistanceElement_initClass()

def SoFocalDistanceElement_set(*args):
  """
    set(SoState state, SoNode node, float distance)
    SoFocalDistanceElement_set(SoState state, float distance)
    """
  return _coin.SoFocalDistanceElement_set(*args)

def SoFocalDistanceElement_get(*args):
  """SoFocalDistanceElement_get(SoState state) -> float"""
  return _coin.SoFocalDistanceElement_get(*args)

def SoFocalDistanceElement_getDefault():
  """SoFocalDistanceElement_getDefault() -> float"""
  return _coin.SoFocalDistanceElement_getDefault()

class SoFontSizeElement(SoFloatElement):
    """Proxy of C++ SoFontSizeElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoFontSizeElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoFontSizeElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoFontSizeElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoFontSizeElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoFontSizeElement_init(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, float fontSize)
        set(SoState state, float fontSize)
        """
        return _coin.SoFontSizeElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> float"""
        return _coin.SoFontSizeElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> float"""
        return _coin.SoFontSizeElement_getDefault()

    getDefault = staticmethod(getDefault)
SoFontSizeElement_swigregister = _coin.SoFontSizeElement_swigregister
SoFontSizeElement_swigregister(SoFontSizeElement)

def SoFontSizeElement_getClassTypeId():
  """SoFontSizeElement_getClassTypeId() -> SoType"""
  return _coin.SoFontSizeElement_getClassTypeId()

def SoFontSizeElement_getClassStackIndex():
  """SoFontSizeElement_getClassStackIndex() -> int"""
  return _coin.SoFontSizeElement_getClassStackIndex()

def SoFontSizeElement_createInstance():
  """SoFontSizeElement_createInstance() -> void"""
  return _coin.SoFontSizeElement_createInstance()

def SoFontSizeElement_initClass():
  """SoFontSizeElement_initClass()"""
  return _coin.SoFontSizeElement_initClass()

def SoFontSizeElement_set(*args):
  """
    set(SoState state, SoNode node, float fontSize)
    SoFontSizeElement_set(SoState state, float fontSize)
    """
  return _coin.SoFontSizeElement_set(*args)

def SoFontSizeElement_get(*args):
  """SoFontSizeElement_get(SoState state) -> float"""
  return _coin.SoFontSizeElement_get(*args)

def SoFontSizeElement_getDefault():
  """SoFontSizeElement_getDefault() -> float"""
  return _coin.SoFontSizeElement_getDefault()

class SoLineWidthElement(SoFloatElement):
    """Proxy of C++ SoLineWidthElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoLineWidthElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoLineWidthElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoLineWidthElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoLineWidthElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoLineWidthElement_init(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, float lineWidth)
        set(SoState state, float lineWidth)
        """
        return _coin.SoLineWidthElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> float"""
        return _coin.SoLineWidthElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> float"""
        return _coin.SoLineWidthElement_getDefault()

    getDefault = staticmethod(getDefault)
SoLineWidthElement_swigregister = _coin.SoLineWidthElement_swigregister
SoLineWidthElement_swigregister(SoLineWidthElement)

def SoLineWidthElement_getClassTypeId():
  """SoLineWidthElement_getClassTypeId() -> SoType"""
  return _coin.SoLineWidthElement_getClassTypeId()

def SoLineWidthElement_getClassStackIndex():
  """SoLineWidthElement_getClassStackIndex() -> int"""
  return _coin.SoLineWidthElement_getClassStackIndex()

def SoLineWidthElement_createInstance():
  """SoLineWidthElement_createInstance() -> void"""
  return _coin.SoLineWidthElement_createInstance()

def SoLineWidthElement_initClass():
  """SoLineWidthElement_initClass()"""
  return _coin.SoLineWidthElement_initClass()

def SoLineWidthElement_set(*args):
  """
    set(SoState state, SoNode node, float lineWidth)
    SoLineWidthElement_set(SoState state, float lineWidth)
    """
  return _coin.SoLineWidthElement_set(*args)

def SoLineWidthElement_get(*args):
  """SoLineWidthElement_get(SoState state) -> float"""
  return _coin.SoLineWidthElement_get(*args)

def SoLineWidthElement_getDefault():
  """SoLineWidthElement_getDefault() -> float"""
  return _coin.SoLineWidthElement_getDefault()

class SoGLLineWidthElement(SoLineWidthElement):
    """Proxy of C++ SoGLLineWidthElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLLineWidthElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLLineWidthElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLLineWidthElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLLineWidthElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLLineWidthElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoGLLineWidthElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLLineWidthElement_pop(self, *args)

SoGLLineWidthElement_swigregister = _coin.SoGLLineWidthElement_swigregister
SoGLLineWidthElement_swigregister(SoGLLineWidthElement)

def SoGLLineWidthElement_getClassTypeId():
  """SoGLLineWidthElement_getClassTypeId() -> SoType"""
  return _coin.SoGLLineWidthElement_getClassTypeId()

def SoGLLineWidthElement_getClassStackIndex():
  """SoGLLineWidthElement_getClassStackIndex() -> int"""
  return _coin.SoGLLineWidthElement_getClassStackIndex()

def SoGLLineWidthElement_createInstance():
  """SoGLLineWidthElement_createInstance() -> void"""
  return _coin.SoGLLineWidthElement_createInstance()

def SoGLLineWidthElement_initClass():
  """SoGLLineWidthElement_initClass()"""
  return _coin.SoGLLineWidthElement_initClass()

class SoPointSizeElement(SoFloatElement):
    """Proxy of C++ SoPointSizeElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoPointSizeElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoPointSizeElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoPointSizeElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoPointSizeElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoPointSizeElement_init(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, float pointSize)
        set(SoState state, float pointSize)
        """
        return _coin.SoPointSizeElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> float"""
        return _coin.SoPointSizeElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> float"""
        return _coin.SoPointSizeElement_getDefault()

    getDefault = staticmethod(getDefault)
SoPointSizeElement_swigregister = _coin.SoPointSizeElement_swigregister
SoPointSizeElement_swigregister(SoPointSizeElement)

def SoPointSizeElement_getClassTypeId():
  """SoPointSizeElement_getClassTypeId() -> SoType"""
  return _coin.SoPointSizeElement_getClassTypeId()

def SoPointSizeElement_getClassStackIndex():
  """SoPointSizeElement_getClassStackIndex() -> int"""
  return _coin.SoPointSizeElement_getClassStackIndex()

def SoPointSizeElement_createInstance():
  """SoPointSizeElement_createInstance() -> void"""
  return _coin.SoPointSizeElement_createInstance()

def SoPointSizeElement_initClass():
  """SoPointSizeElement_initClass()"""
  return _coin.SoPointSizeElement_initClass()

def SoPointSizeElement_set(*args):
  """
    set(SoState state, SoNode node, float pointSize)
    SoPointSizeElement_set(SoState state, float pointSize)
    """
  return _coin.SoPointSizeElement_set(*args)

def SoPointSizeElement_get(*args):
  """SoPointSizeElement_get(SoState state) -> float"""
  return _coin.SoPointSizeElement_get(*args)

def SoPointSizeElement_getDefault():
  """SoPointSizeElement_getDefault() -> float"""
  return _coin.SoPointSizeElement_getDefault()

class SoGLPointSizeElement(SoPointSizeElement):
    """Proxy of C++ SoGLPointSizeElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLPointSizeElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLPointSizeElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLPointSizeElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLPointSizeElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLPointSizeElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoGLPointSizeElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLPointSizeElement_pop(self, *args)

SoGLPointSizeElement_swigregister = _coin.SoGLPointSizeElement_swigregister
SoGLPointSizeElement_swigregister(SoGLPointSizeElement)

def SoGLPointSizeElement_getClassTypeId():
  """SoGLPointSizeElement_getClassTypeId() -> SoType"""
  return _coin.SoGLPointSizeElement_getClassTypeId()

def SoGLPointSizeElement_getClassStackIndex():
  """SoGLPointSizeElement_getClassStackIndex() -> int"""
  return _coin.SoGLPointSizeElement_getClassStackIndex()

def SoGLPointSizeElement_createInstance():
  """SoGLPointSizeElement_createInstance() -> void"""
  return _coin.SoGLPointSizeElement_createInstance()

def SoGLPointSizeElement_initClass():
  """SoGLPointSizeElement_initClass()"""
  return _coin.SoGLPointSizeElement_initClass()

class SoTextureQualityElement(SoFloatElement):
    """Proxy of C++ SoTextureQualityElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextureQualityElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoTextureQualityElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoTextureQualityElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoTextureQualityElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoTextureQualityElement_init(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, float quality)
        set(SoState state, float quality)
        """
        return _coin.SoTextureQualityElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> float"""
        return _coin.SoTextureQualityElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> float"""
        return _coin.SoTextureQualityElement_getDefault()

    getDefault = staticmethod(getDefault)
SoTextureQualityElement_swigregister = _coin.SoTextureQualityElement_swigregister
SoTextureQualityElement_swigregister(SoTextureQualityElement)

def SoTextureQualityElement_getClassTypeId():
  """SoTextureQualityElement_getClassTypeId() -> SoType"""
  return _coin.SoTextureQualityElement_getClassTypeId()

def SoTextureQualityElement_getClassStackIndex():
  """SoTextureQualityElement_getClassStackIndex() -> int"""
  return _coin.SoTextureQualityElement_getClassStackIndex()

def SoTextureQualityElement_createInstance():
  """SoTextureQualityElement_createInstance() -> void"""
  return _coin.SoTextureQualityElement_createInstance()

def SoTextureQualityElement_initClass():
  """SoTextureQualityElement_initClass()"""
  return _coin.SoTextureQualityElement_initClass()

def SoTextureQualityElement_set(*args):
  """
    set(SoState state, SoNode node, float quality)
    SoTextureQualityElement_set(SoState state, float quality)
    """
  return _coin.SoTextureQualityElement_set(*args)

def SoTextureQualityElement_get(*args):
  """SoTextureQualityElement_get(SoState state) -> float"""
  return _coin.SoTextureQualityElement_get(*args)

def SoTextureQualityElement_getDefault():
  """SoTextureQualityElement_getDefault() -> float"""
  return _coin.SoTextureQualityElement_getDefault()

class SoTextureOverrideElement(SoElement):
    """Proxy of C++ SoTextureOverrideElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextureOverrideElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoTextureOverrideElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoTextureOverrideElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoTextureOverrideElement_initClass()

    initClass = staticmethod(initClass)
    def matches(self, *args):
        """matches(self, SoElement element) -> SbBool"""
        return _coin.SoTextureOverrideElement_matches(self, *args)

    def copyMatchInfo(self):
        """copyMatchInfo(self) -> SoElement"""
        return _coin.SoTextureOverrideElement_copyMatchInfo(self)

    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoTextureOverrideElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoTextureOverrideElement_push(self, *args)

    def getQualityOverride(*args):
        """getQualityOverride(SoState state) -> SbBool"""
        return _coin.SoTextureOverrideElement_getQualityOverride(*args)

    getQualityOverride = staticmethod(getQualityOverride)
    def getImageOverride(*args):
        """getImageOverride(SoState state) -> SbBool"""
        return _coin.SoTextureOverrideElement_getImageOverride(*args)

    getImageOverride = staticmethod(getImageOverride)
    def getBumpMapOverride(*args):
        """getBumpMapOverride(SoState state) -> SbBool"""
        return _coin.SoTextureOverrideElement_getBumpMapOverride(*args)

    getBumpMapOverride = staticmethod(getBumpMapOverride)
    def setQualityOverride(*args):
        """setQualityOverride(SoState state, SbBool value)"""
        return _coin.SoTextureOverrideElement_setQualityOverride(*args)

    setQualityOverride = staticmethod(setQualityOverride)
    def setImageOverride(*args):
        """setImageOverride(SoState state, SbBool value)"""
        return _coin.SoTextureOverrideElement_setImageOverride(*args)

    setImageOverride = staticmethod(setImageOverride)
    def setBumpMapOverride(*args):
        """setBumpMapOverride(SoState state, SbBool value)"""
        return _coin.SoTextureOverrideElement_setBumpMapOverride(*args)

    setBumpMapOverride = staticmethod(setBumpMapOverride)
    def output(self, *args):
        """output(self, FILE fp)"""
        return _coin.SoTextureOverrideElement_output(self, *args)

SoTextureOverrideElement_swigregister = _coin.SoTextureOverrideElement_swigregister
SoTextureOverrideElement_swigregister(SoTextureOverrideElement)

def SoTextureOverrideElement_getClassTypeId():
  """SoTextureOverrideElement_getClassTypeId() -> SoType"""
  return _coin.SoTextureOverrideElement_getClassTypeId()

def SoTextureOverrideElement_getClassStackIndex():
  """SoTextureOverrideElement_getClassStackIndex() -> int"""
  return _coin.SoTextureOverrideElement_getClassStackIndex()

def SoTextureOverrideElement_createInstance():
  """SoTextureOverrideElement_createInstance() -> void"""
  return _coin.SoTextureOverrideElement_createInstance()

def SoTextureOverrideElement_initClass():
  """SoTextureOverrideElement_initClass()"""
  return _coin.SoTextureOverrideElement_initClass()

def SoTextureOverrideElement_getQualityOverride(*args):
  """SoTextureOverrideElement_getQualityOverride(SoState state) -> SbBool"""
  return _coin.SoTextureOverrideElement_getQualityOverride(*args)

def SoTextureOverrideElement_getImageOverride(*args):
  """SoTextureOverrideElement_getImageOverride(SoState state) -> SbBool"""
  return _coin.SoTextureOverrideElement_getImageOverride(*args)

def SoTextureOverrideElement_getBumpMapOverride(*args):
  """SoTextureOverrideElement_getBumpMapOverride(SoState state) -> SbBool"""
  return _coin.SoTextureOverrideElement_getBumpMapOverride(*args)

def SoTextureOverrideElement_setQualityOverride(*args):
  """SoTextureOverrideElement_setQualityOverride(SoState state, SbBool value)"""
  return _coin.SoTextureOverrideElement_setQualityOverride(*args)

def SoTextureOverrideElement_setImageOverride(*args):
  """SoTextureOverrideElement_setImageOverride(SoState state, SbBool value)"""
  return _coin.SoTextureOverrideElement_setImageOverride(*args)

def SoTextureOverrideElement_setBumpMapOverride(*args):
  """SoTextureOverrideElement_setBumpMapOverride(SoState state, SbBool value)"""
  return _coin.SoTextureOverrideElement_setBumpMapOverride(*args)

class SoGLRenderPassElement(SoElement):
    """Proxy of C++ SoGLRenderPassElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLRenderPassElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLRenderPassElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLRenderPassElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLRenderPassElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLRenderPassElement_init(self, *args)

    def matches(self, *args):
        """matches(self, SoElement element) -> SbBool"""
        return _coin.SoGLRenderPassElement_matches(self, *args)

    def copyMatchInfo(self):
        """copyMatchInfo(self) -> SoElement"""
        return _coin.SoGLRenderPassElement_copyMatchInfo(self)

    def set(*args):
        """set(SoState state, int passNumber)"""
        return _coin.SoGLRenderPassElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> int"""
        return _coin.SoGLRenderPassElement_get(*args)

    get = staticmethod(get)
SoGLRenderPassElement_swigregister = _coin.SoGLRenderPassElement_swigregister
SoGLRenderPassElement_swigregister(SoGLRenderPassElement)

def SoGLRenderPassElement_getClassTypeId():
  """SoGLRenderPassElement_getClassTypeId() -> SoType"""
  return _coin.SoGLRenderPassElement_getClassTypeId()

def SoGLRenderPassElement_getClassStackIndex():
  """SoGLRenderPassElement_getClassStackIndex() -> int"""
  return _coin.SoGLRenderPassElement_getClassStackIndex()

def SoGLRenderPassElement_createInstance():
  """SoGLRenderPassElement_createInstance() -> void"""
  return _coin.SoGLRenderPassElement_createInstance()

def SoGLRenderPassElement_initClass():
  """SoGLRenderPassElement_initClass()"""
  return _coin.SoGLRenderPassElement_initClass()

def SoGLRenderPassElement_set(*args):
  """SoGLRenderPassElement_set(SoState state, int passNumber)"""
  return _coin.SoGLRenderPassElement_set(*args)

def SoGLRenderPassElement_get(*args):
  """SoGLRenderPassElement_get(SoState state) -> int"""
  return _coin.SoGLRenderPassElement_get(*args)

class SoGLUpdateAreaElement(SoElement):
    """Proxy of C++ SoGLUpdateAreaElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLUpdateAreaElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLUpdateAreaElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLUpdateAreaElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLUpdateAreaElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLUpdateAreaElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoGLUpdateAreaElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLUpdateAreaElement_pop(self, *args)

    def matches(self, *args):
        """matches(self, SoElement element) -> SbBool"""
        return _coin.SoGLUpdateAreaElement_matches(self, *args)

    def copyMatchInfo(self):
        """copyMatchInfo(self) -> SoElement"""
        return _coin.SoGLUpdateAreaElement_copyMatchInfo(self)

    def set(*args):
        """set(SoState state, SbVec2f origin, SbVec2f size)"""
        return _coin.SoGLUpdateAreaElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state, SbVec2f origin, SbVec2f size) -> SbBool"""
        return _coin.SoGLUpdateAreaElement_get(*args)

    get = staticmethod(get)
    def getDefaultOrigin():
        """getDefaultOrigin() -> SbVec2f"""
        return _coin.SoGLUpdateAreaElement_getDefaultOrigin()

    getDefaultOrigin = staticmethod(getDefaultOrigin)
    def getDefaultSize():
        """getDefaultSize() -> SbVec2f"""
        return _coin.SoGLUpdateAreaElement_getDefaultSize()

    getDefaultSize = staticmethod(getDefaultSize)
SoGLUpdateAreaElement_swigregister = _coin.SoGLUpdateAreaElement_swigregister
SoGLUpdateAreaElement_swigregister(SoGLUpdateAreaElement)

def SoGLUpdateAreaElement_getClassTypeId():
  """SoGLUpdateAreaElement_getClassTypeId() -> SoType"""
  return _coin.SoGLUpdateAreaElement_getClassTypeId()

def SoGLUpdateAreaElement_getClassStackIndex():
  """SoGLUpdateAreaElement_getClassStackIndex() -> int"""
  return _coin.SoGLUpdateAreaElement_getClassStackIndex()

def SoGLUpdateAreaElement_createInstance():
  """SoGLUpdateAreaElement_createInstance() -> void"""
  return _coin.SoGLUpdateAreaElement_createInstance()

def SoGLUpdateAreaElement_initClass():
  """SoGLUpdateAreaElement_initClass()"""
  return _coin.SoGLUpdateAreaElement_initClass()

def SoGLUpdateAreaElement_set(*args):
  """SoGLUpdateAreaElement_set(SoState state, SbVec2f origin, SbVec2f size)"""
  return _coin.SoGLUpdateAreaElement_set(*args)

def SoGLUpdateAreaElement_get(*args):
  """SoGLUpdateAreaElement_get(SoState state, SbVec2f origin, SbVec2f size) -> SbBool"""
  return _coin.SoGLUpdateAreaElement_get(*args)

def SoGLUpdateAreaElement_getDefaultOrigin():
  """SoGLUpdateAreaElement_getDefaultOrigin() -> SbVec2f"""
  return _coin.SoGLUpdateAreaElement_getDefaultOrigin()

def SoGLUpdateAreaElement_getDefaultSize():
  """SoGLUpdateAreaElement_getDefaultSize() -> SbVec2f"""
  return _coin.SoGLUpdateAreaElement_getDefaultSize()

class SoLocalBBoxMatrixElement(SoElement):
    """Proxy of C++ SoLocalBBoxMatrixElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoLocalBBoxMatrixElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoLocalBBoxMatrixElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoLocalBBoxMatrixElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoLocalBBoxMatrixElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoLocalBBoxMatrixElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoLocalBBoxMatrixElement_push(self, *args)

    def makeIdentity(*args):
        """makeIdentity(SoState state)"""
        return _coin.SoLocalBBoxMatrixElement_makeIdentity(*args)

    makeIdentity = staticmethod(makeIdentity)
    def set(*args):
        """set(SoState state)"""
        return _coin.SoLocalBBoxMatrixElement_set(*args)

    set = staticmethod(set)
    def mult(*args):
        """mult(SoState state)"""
        return _coin.SoLocalBBoxMatrixElement_mult(*args)

    mult = staticmethod(mult)
    def translateBy(*args):
        """translateBy(SoState state, SbVec3f translation)"""
        return _coin.SoLocalBBoxMatrixElement_translateBy(*args)

    translateBy = staticmethod(translateBy)
    def rotateBy(*args):
        """rotateBy(SoState state, SbRotation rotation)"""
        return _coin.SoLocalBBoxMatrixElement_rotateBy(*args)

    rotateBy = staticmethod(rotateBy)
    def scaleBy(*args):
        """scaleBy(SoState state, SbVec3f scaleFactor)"""
        return _coin.SoLocalBBoxMatrixElement_scaleBy(*args)

    scaleBy = staticmethod(scaleBy)
    def pushMatrix(*args):
        """pushMatrix(SoState state) -> SbMatrix"""
        return _coin.SoLocalBBoxMatrixElement_pushMatrix(*args)

    pushMatrix = staticmethod(pushMatrix)
    def popMatrix(*args):
        """popMatrix(SoState state)"""
        return _coin.SoLocalBBoxMatrixElement_popMatrix(*args)

    popMatrix = staticmethod(popMatrix)
    def resetAll(*args):
        """resetAll(SoState state)"""
        return _coin.SoLocalBBoxMatrixElement_resetAll(*args)

    resetAll = staticmethod(resetAll)
    def get(*args):
        """get(SoState state) -> SbMatrix"""
        return _coin.SoLocalBBoxMatrixElement_get(*args)

    get = staticmethod(get)
    def matches(self, *args):
        """matches(self, SoElement element) -> SbBool"""
        return _coin.SoLocalBBoxMatrixElement_matches(self, *args)

    def copyMatchInfo(self):
        """copyMatchInfo(self) -> SoElement"""
        return _coin.SoLocalBBoxMatrixElement_copyMatchInfo(self)

SoLocalBBoxMatrixElement_swigregister = _coin.SoLocalBBoxMatrixElement_swigregister
SoLocalBBoxMatrixElement_swigregister(SoLocalBBoxMatrixElement)

def SoLocalBBoxMatrixElement_getClassTypeId():
  """SoLocalBBoxMatrixElement_getClassTypeId() -> SoType"""
  return _coin.SoLocalBBoxMatrixElement_getClassTypeId()

def SoLocalBBoxMatrixElement_getClassStackIndex():
  """SoLocalBBoxMatrixElement_getClassStackIndex() -> int"""
  return _coin.SoLocalBBoxMatrixElement_getClassStackIndex()

def SoLocalBBoxMatrixElement_createInstance():
  """SoLocalBBoxMatrixElement_createInstance() -> void"""
  return _coin.SoLocalBBoxMatrixElement_createInstance()

def SoLocalBBoxMatrixElement_initClass():
  """SoLocalBBoxMatrixElement_initClass()"""
  return _coin.SoLocalBBoxMatrixElement_initClass()

def SoLocalBBoxMatrixElement_makeIdentity(*args):
  """SoLocalBBoxMatrixElement_makeIdentity(SoState state)"""
  return _coin.SoLocalBBoxMatrixElement_makeIdentity(*args)

def SoLocalBBoxMatrixElement_set(*args):
  """SoLocalBBoxMatrixElement_set(SoState state)"""
  return _coin.SoLocalBBoxMatrixElement_set(*args)

def SoLocalBBoxMatrixElement_mult(*args):
  """SoLocalBBoxMatrixElement_mult(SoState state)"""
  return _coin.SoLocalBBoxMatrixElement_mult(*args)

def SoLocalBBoxMatrixElement_translateBy(*args):
  """SoLocalBBoxMatrixElement_translateBy(SoState state, SbVec3f translation)"""
  return _coin.SoLocalBBoxMatrixElement_translateBy(*args)

def SoLocalBBoxMatrixElement_rotateBy(*args):
  """SoLocalBBoxMatrixElement_rotateBy(SoState state, SbRotation rotation)"""
  return _coin.SoLocalBBoxMatrixElement_rotateBy(*args)

def SoLocalBBoxMatrixElement_scaleBy(*args):
  """SoLocalBBoxMatrixElement_scaleBy(SoState state, SbVec3f scaleFactor)"""
  return _coin.SoLocalBBoxMatrixElement_scaleBy(*args)

def SoLocalBBoxMatrixElement_pushMatrix(*args):
  """SoLocalBBoxMatrixElement_pushMatrix(SoState state) -> SbMatrix"""
  return _coin.SoLocalBBoxMatrixElement_pushMatrix(*args)

def SoLocalBBoxMatrixElement_popMatrix(*args):
  """SoLocalBBoxMatrixElement_popMatrix(SoState state)"""
  return _coin.SoLocalBBoxMatrixElement_popMatrix(*args)

def SoLocalBBoxMatrixElement_resetAll(*args):
  """SoLocalBBoxMatrixElement_resetAll(SoState state)"""
  return _coin.SoLocalBBoxMatrixElement_resetAll(*args)

def SoLocalBBoxMatrixElement_get(*args):
  """SoLocalBBoxMatrixElement_get(SoState state) -> SbMatrix"""
  return _coin.SoLocalBBoxMatrixElement_get(*args)

class SoOverrideElement(SoElement):
    """Proxy of C++ SoOverrideElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoOverrideElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoOverrideElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoOverrideElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoOverrideElement_initClass()

    initClass = staticmethod(initClass)
    AMBIENT_COLOR = _coin.SoOverrideElement_AMBIENT_COLOR
    COLOR_INDEX = _coin.SoOverrideElement_COLOR_INDEX
    COMPLEXITY = _coin.SoOverrideElement_COMPLEXITY
    COMPLEXITY_TYPE = _coin.SoOverrideElement_COMPLEXITY_TYPE
    CREASE_ANGLE = _coin.SoOverrideElement_CREASE_ANGLE
    DIFFUSE_COLOR = _coin.SoOverrideElement_DIFFUSE_COLOR
    DRAW_STYLE = _coin.SoOverrideElement_DRAW_STYLE
    EMISSIVE_COLOR = _coin.SoOverrideElement_EMISSIVE_COLOR
    FONT_NAME = _coin.SoOverrideElement_FONT_NAME
    FONT_SIZE = _coin.SoOverrideElement_FONT_SIZE
    LIGHT_MODEL = _coin.SoOverrideElement_LIGHT_MODEL
    LINE_PATTERN = _coin.SoOverrideElement_LINE_PATTERN
    LINE_WIDTH = _coin.SoOverrideElement_LINE_WIDTH
    MATERIAL_BINDING = _coin.SoOverrideElement_MATERIAL_BINDING
    POINT_SIZE = _coin.SoOverrideElement_POINT_SIZE
    PICK_STYLE = _coin.SoOverrideElement_PICK_STYLE
    SHAPE_HINTS = _coin.SoOverrideElement_SHAPE_HINTS
    SHININESS = _coin.SoOverrideElement_SHININESS
    SPECULAR_COLOR = _coin.SoOverrideElement_SPECULAR_COLOR
    POLYGON_OFFSET = _coin.SoOverrideElement_POLYGON_OFFSET
    TRANSPARENCY = _coin.SoOverrideElement_TRANSPARENCY
    TRANSPARENCY_TYPE = _coin.SoOverrideElement_TRANSPARENCY_TYPE
    NORMAL_VECTOR = _coin.SoOverrideElement_NORMAL_VECTOR
    NORMAL_BINDING = _coin.SoOverrideElement_NORMAL_BINDING
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoOverrideElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoOverrideElement_push(self, *args)

    def matches(self, *args):
        """matches(self, SoElement element) -> SbBool"""
        return _coin.SoOverrideElement_matches(self, *args)

    def copyMatchInfo(self):
        """copyMatchInfo(self) -> SoElement"""
        return _coin.SoOverrideElement_copyMatchInfo(self)

    def getFlags(*args):
        """getFlags(SoState state) -> uint32_t"""
        return _coin.SoOverrideElement_getFlags(*args)

    getFlags = staticmethod(getFlags)
    def getAmbientColorOverride(*args):
        """getAmbientColorOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getAmbientColorOverride(*args)

    getAmbientColorOverride = staticmethod(getAmbientColorOverride)
    def getColorIndexOverride(*args):
        """getColorIndexOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getColorIndexOverride(*args)

    getColorIndexOverride = staticmethod(getColorIndexOverride)
    def getComplexityOverride(*args):
        """getComplexityOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getComplexityOverride(*args)

    getComplexityOverride = staticmethod(getComplexityOverride)
    def getComplexityTypeOverride(*args):
        """getComplexityTypeOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getComplexityTypeOverride(*args)

    getComplexityTypeOverride = staticmethod(getComplexityTypeOverride)
    def getCreaseAngleOverride(*args):
        """getCreaseAngleOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getCreaseAngleOverride(*args)

    getCreaseAngleOverride = staticmethod(getCreaseAngleOverride)
    def getDiffuseColorOverride(*args):
        """getDiffuseColorOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getDiffuseColorOverride(*args)

    getDiffuseColorOverride = staticmethod(getDiffuseColorOverride)
    def getDrawStyleOverride(*args):
        """getDrawStyleOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getDrawStyleOverride(*args)

    getDrawStyleOverride = staticmethod(getDrawStyleOverride)
    def getEmissiveColorOverride(*args):
        """getEmissiveColorOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getEmissiveColorOverride(*args)

    getEmissiveColorOverride = staticmethod(getEmissiveColorOverride)
    def getFontNameOverride(*args):
        """getFontNameOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getFontNameOverride(*args)

    getFontNameOverride = staticmethod(getFontNameOverride)
    def getFontSizeOverride(*args):
        """getFontSizeOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getFontSizeOverride(*args)

    getFontSizeOverride = staticmethod(getFontSizeOverride)
    def getLightModelOverride(*args):
        """getLightModelOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getLightModelOverride(*args)

    getLightModelOverride = staticmethod(getLightModelOverride)
    def getLinePatternOverride(*args):
        """getLinePatternOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getLinePatternOverride(*args)

    getLinePatternOverride = staticmethod(getLinePatternOverride)
    def getLineWidthOverride(*args):
        """getLineWidthOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getLineWidthOverride(*args)

    getLineWidthOverride = staticmethod(getLineWidthOverride)
    def getMaterialBindingOverride(*args):
        """getMaterialBindingOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getMaterialBindingOverride(*args)

    getMaterialBindingOverride = staticmethod(getMaterialBindingOverride)
    def getPickStyleOverride(*args):
        """getPickStyleOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getPickStyleOverride(*args)

    getPickStyleOverride = staticmethod(getPickStyleOverride)
    def getPointSizeOverride(*args):
        """getPointSizeOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getPointSizeOverride(*args)

    getPointSizeOverride = staticmethod(getPointSizeOverride)
    def getPolygonOffsetOverride(*args):
        """getPolygonOffsetOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getPolygonOffsetOverride(*args)

    getPolygonOffsetOverride = staticmethod(getPolygonOffsetOverride)
    def getShapeHintsOverride(*args):
        """getShapeHintsOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getShapeHintsOverride(*args)

    getShapeHintsOverride = staticmethod(getShapeHintsOverride)
    def getShininessOverride(*args):
        """getShininessOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getShininessOverride(*args)

    getShininessOverride = staticmethod(getShininessOverride)
    def getSpecularColorOverride(*args):
        """getSpecularColorOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getSpecularColorOverride(*args)

    getSpecularColorOverride = staticmethod(getSpecularColorOverride)
    def getTransparencyOverride(*args):
        """getTransparencyOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getTransparencyOverride(*args)

    getTransparencyOverride = staticmethod(getTransparencyOverride)
    def getTransparencyTypeOverride(*args):
        """getTransparencyTypeOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getTransparencyTypeOverride(*args)

    getTransparencyTypeOverride = staticmethod(getTransparencyTypeOverride)
    def getNormalVectorOverride(*args):
        """getNormalVectorOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getNormalVectorOverride(*args)

    getNormalVectorOverride = staticmethod(getNormalVectorOverride)
    def getNormalBindingOverride(*args):
        """getNormalBindingOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getNormalBindingOverride(*args)

    getNormalBindingOverride = staticmethod(getNormalBindingOverride)
    def setAmbientColorOverride(*args):
        """setAmbientColorOverride(SoState state, SoNode node, SbBool override)"""
        return _coin.SoOverrideElement_setAmbientColorOverride(*args)

    setAmbientColorOverride = staticmethod(setAmbientColorOverride)
    def setColorIndexOverride(*args):
        """setColorIndexOverride(SoState state, SoNode node, SbBool override)"""
        return _coin.SoOverrideElement_setColorIndexOverride(*args)

    setColorIndexOverride = staticmethod(setColorIndexOverride)
    def setComplexityOverride(*args):
        """setComplexityOverride(SoState state, SoNode node, SbBool override)"""
        return _coin.SoOverrideElement_setComplexityOverride(*args)

    setComplexityOverride = staticmethod(setComplexityOverride)
    def setComplexityTypeOverride(*args):
        """setComplexityTypeOverride(SoState state, SoNode node, SbBool override)"""
        return _coin.SoOverrideElement_setComplexityTypeOverride(*args)

    setComplexityTypeOverride = staticmethod(setComplexityTypeOverride)
    def setCreaseAngleOverride(*args):
        """setCreaseAngleOverride(SoState state, SoNode node, SbBool override)"""
        return _coin.SoOverrideElement_setCreaseAngleOverride(*args)

    setCreaseAngleOverride = staticmethod(setCreaseAngleOverride)
    def setDiffuseColorOverride(*args):
        """setDiffuseColorOverride(SoState state, SoNode node, SbBool override)"""
        return _coin.SoOverrideElement_setDiffuseColorOverride(*args)

    setDiffuseColorOverride = staticmethod(setDiffuseColorOverride)
    def setDrawStyleOverride(*args):
        """setDrawStyleOverride(SoState state, SoNode node, SbBool override)"""
        return _coin.SoOverrideElement_setDrawStyleOverride(*args)

    setDrawStyleOverride = staticmethod(setDrawStyleOverride)
    def setEmissiveColorOverride(*args):
        """setEmissiveColorOverride(SoState state, SoNode node, SbBool override)"""
        return _coin.SoOverrideElement_setEmissiveColorOverride(*args)

    setEmissiveColorOverride = staticmethod(setEmissiveColorOverride)
    def setFontNameOverride(*args):
        """setFontNameOverride(SoState state, SoNode node, SbBool override)"""
        return _coin.SoOverrideElement_setFontNameOverride(*args)

    setFontNameOverride = staticmethod(setFontNameOverride)
    def setFontSizeOverride(*args):
        """setFontSizeOverride(SoState state, SoNode node, SbBool override)"""
        return _coin.SoOverrideElement_setFontSizeOverride(*args)

    setFontSizeOverride = staticmethod(setFontSizeOverride)
    def setLightModelOverride(*args):
        """setLightModelOverride(SoState state, SoNode node, SbBool override)"""
        return _coin.SoOverrideElement_setLightModelOverride(*args)

    setLightModelOverride = staticmethod(setLightModelOverride)
    def setLinePatternOverride(*args):
        """setLinePatternOverride(SoState state, SoNode node, SbBool override)"""
        return _coin.SoOverrideElement_setLinePatternOverride(*args)

    setLinePatternOverride = staticmethod(setLinePatternOverride)
    def setLineWidthOverride(*args):
        """setLineWidthOverride(SoState state, SoNode node, SbBool override)"""
        return _coin.SoOverrideElement_setLineWidthOverride(*args)

    setLineWidthOverride = staticmethod(setLineWidthOverride)
    def setMaterialBindingOverride(*args):
        """setMaterialBindingOverride(SoState state, SoNode node, SbBool override)"""
        return _coin.SoOverrideElement_setMaterialBindingOverride(*args)

    setMaterialBindingOverride = staticmethod(setMaterialBindingOverride)
    def setPickStyleOverride(*args):
        """setPickStyleOverride(SoState state, SoNode node, SbBool override)"""
        return _coin.SoOverrideElement_setPickStyleOverride(*args)

    setPickStyleOverride = staticmethod(setPickStyleOverride)
    def setPointSizeOverride(*args):
        """setPointSizeOverride(SoState state, SoNode node, SbBool override)"""
        return _coin.SoOverrideElement_setPointSizeOverride(*args)

    setPointSizeOverride = staticmethod(setPointSizeOverride)
    def setPolygonOffsetOverride(*args):
        """setPolygonOffsetOverride(SoState state, SoNode node, SbBool override)"""
        return _coin.SoOverrideElement_setPolygonOffsetOverride(*args)

    setPolygonOffsetOverride = staticmethod(setPolygonOffsetOverride)
    def setShapeHintsOverride(*args):
        """setShapeHintsOverride(SoState state, SoNode node, SbBool override)"""
        return _coin.SoOverrideElement_setShapeHintsOverride(*args)

    setShapeHintsOverride = staticmethod(setShapeHintsOverride)
    def setShininessOverride(*args):
        """setShininessOverride(SoState state, SoNode node, SbBool override)"""
        return _coin.SoOverrideElement_setShininessOverride(*args)

    setShininessOverride = staticmethod(setShininessOverride)
    def setSpecularColorOverride(*args):
        """setSpecularColorOverride(SoState state, SoNode node, SbBool override)"""
        return _coin.SoOverrideElement_setSpecularColorOverride(*args)

    setSpecularColorOverride = staticmethod(setSpecularColorOverride)
    def setTransparencyOverride(*args):
        """setTransparencyOverride(SoState state, SoNode node, SbBool override)"""
        return _coin.SoOverrideElement_setTransparencyOverride(*args)

    setTransparencyOverride = staticmethod(setTransparencyOverride)
    def setTransparencyTypeOverride(*args):
        """setTransparencyTypeOverride(SoState state, SoNode node, SbBool override)"""
        return _coin.SoOverrideElement_setTransparencyTypeOverride(*args)

    setTransparencyTypeOverride = staticmethod(setTransparencyTypeOverride)
    def setNormalVectorOverride(*args):
        """setNormalVectorOverride(SoState state, SoNode node, SbBool override)"""
        return _coin.SoOverrideElement_setNormalVectorOverride(*args)

    setNormalVectorOverride = staticmethod(setNormalVectorOverride)
    def setNormalBindingOverride(*args):
        """setNormalBindingOverride(SoState state, SoNode node, SbBool override)"""
        return _coin.SoOverrideElement_setNormalBindingOverride(*args)

    setNormalBindingOverride = staticmethod(setNormalBindingOverride)
    def output(self, *args):
        """output(self, FILE file)"""
        return _coin.SoOverrideElement_output(self, *args)

SoOverrideElement_swigregister = _coin.SoOverrideElement_swigregister
SoOverrideElement_swigregister(SoOverrideElement)

def SoOverrideElement_getClassTypeId():
  """SoOverrideElement_getClassTypeId() -> SoType"""
  return _coin.SoOverrideElement_getClassTypeId()

def SoOverrideElement_getClassStackIndex():
  """SoOverrideElement_getClassStackIndex() -> int"""
  return _coin.SoOverrideElement_getClassStackIndex()

def SoOverrideElement_createInstance():
  """SoOverrideElement_createInstance() -> void"""
  return _coin.SoOverrideElement_createInstance()

def SoOverrideElement_initClass():
  """SoOverrideElement_initClass()"""
  return _coin.SoOverrideElement_initClass()

def SoOverrideElement_getFlags(*args):
  """SoOverrideElement_getFlags(SoState state) -> uint32_t"""
  return _coin.SoOverrideElement_getFlags(*args)

def SoOverrideElement_getAmbientColorOverride(*args):
  """SoOverrideElement_getAmbientColorOverride(SoState state) -> SbBool"""
  return _coin.SoOverrideElement_getAmbientColorOverride(*args)

def SoOverrideElement_getColorIndexOverride(*args):
  """SoOverrideElement_getColorIndexOverride(SoState state) -> SbBool"""
  return _coin.SoOverrideElement_getColorIndexOverride(*args)

def SoOverrideElement_getComplexityOverride(*args):
  """SoOverrideElement_getComplexityOverride(SoState state) -> SbBool"""
  return _coin.SoOverrideElement_getComplexityOverride(*args)

def SoOverrideElement_getComplexityTypeOverride(*args):
  """SoOverrideElement_getComplexityTypeOverride(SoState state) -> SbBool"""
  return _coin.SoOverrideElement_getComplexityTypeOverride(*args)

def SoOverrideElement_getCreaseAngleOverride(*args):
  """SoOverrideElement_getCreaseAngleOverride(SoState state) -> SbBool"""
  return _coin.SoOverrideElement_getCreaseAngleOverride(*args)

def SoOverrideElement_getDiffuseColorOverride(*args):
  """SoOverrideElement_getDiffuseColorOverride(SoState state) -> SbBool"""
  return _coin.SoOverrideElement_getDiffuseColorOverride(*args)

def SoOverrideElement_getDrawStyleOverride(*args):
  """SoOverrideElement_getDrawStyleOverride(SoState state) -> SbBool"""
  return _coin.SoOverrideElement_getDrawStyleOverride(*args)

def SoOverrideElement_getEmissiveColorOverride(*args):
  """SoOverrideElement_getEmissiveColorOverride(SoState state) -> SbBool"""
  return _coin.SoOverrideElement_getEmissiveColorOverride(*args)

def SoOverrideElement_getFontNameOverride(*args):
  """SoOverrideElement_getFontNameOverride(SoState state) -> SbBool"""
  return _coin.SoOverrideElement_getFontNameOverride(*args)

def SoOverrideElement_getFontSizeOverride(*args):
  """SoOverrideElement_getFontSizeOverride(SoState state) -> SbBool"""
  return _coin.SoOverrideElement_getFontSizeOverride(*args)

def SoOverrideElement_getLightModelOverride(*args):
  """SoOverrideElement_getLightModelOverride(SoState state) -> SbBool"""
  return _coin.SoOverrideElement_getLightModelOverride(*args)

def SoOverrideElement_getLinePatternOverride(*args):
  """SoOverrideElement_getLinePatternOverride(SoState state) -> SbBool"""
  return _coin.SoOverrideElement_getLinePatternOverride(*args)

def SoOverrideElement_getLineWidthOverride(*args):
  """SoOverrideElement_getLineWidthOverride(SoState state) -> SbBool"""
  return _coin.SoOverrideElement_getLineWidthOverride(*args)

def SoOverrideElement_getMaterialBindingOverride(*args):
  """SoOverrideElement_getMaterialBindingOverride(SoState state) -> SbBool"""
  return _coin.SoOverrideElement_getMaterialBindingOverride(*args)

def SoOverrideElement_getPickStyleOverride(*args):
  """SoOverrideElement_getPickStyleOverride(SoState state) -> SbBool"""
  return _coin.SoOverrideElement_getPickStyleOverride(*args)

def SoOverrideElement_getPointSizeOverride(*args):
  """SoOverrideElement_getPointSizeOverride(SoState state) -> SbBool"""
  return _coin.SoOverrideElement_getPointSizeOverride(*args)

def SoOverrideElement_getPolygonOffsetOverride(*args):
  """SoOverrideElement_getPolygonOffsetOverride(SoState state) -> SbBool"""
  return _coin.SoOverrideElement_getPolygonOffsetOverride(*args)

def SoOverrideElement_getShapeHintsOverride(*args):
  """SoOverrideElement_getShapeHintsOverride(SoState state) -> SbBool"""
  return _coin.SoOverrideElement_getShapeHintsOverride(*args)

def SoOverrideElement_getShininessOverride(*args):
  """SoOverrideElement_getShininessOverride(SoState state) -> SbBool"""
  return _coin.SoOverrideElement_getShininessOverride(*args)

def SoOverrideElement_getSpecularColorOverride(*args):
  """SoOverrideElement_getSpecularColorOverride(SoState state) -> SbBool"""
  return _coin.SoOverrideElement_getSpecularColorOverride(*args)

def SoOverrideElement_getTransparencyOverride(*args):
  """SoOverrideElement_getTransparencyOverride(SoState state) -> SbBool"""
  return _coin.SoOverrideElement_getTransparencyOverride(*args)

def SoOverrideElement_getTransparencyTypeOverride(*args):
  """SoOverrideElement_getTransparencyTypeOverride(SoState state) -> SbBool"""
  return _coin.SoOverrideElement_getTransparencyTypeOverride(*args)

def SoOverrideElement_getNormalVectorOverride(*args):
  """SoOverrideElement_getNormalVectorOverride(SoState state) -> SbBool"""
  return _coin.SoOverrideElement_getNormalVectorOverride(*args)

def SoOverrideElement_getNormalBindingOverride(*args):
  """SoOverrideElement_getNormalBindingOverride(SoState state) -> SbBool"""
  return _coin.SoOverrideElement_getNormalBindingOverride(*args)

def SoOverrideElement_setAmbientColorOverride(*args):
  """SoOverrideElement_setAmbientColorOverride(SoState state, SoNode node, SbBool override)"""
  return _coin.SoOverrideElement_setAmbientColorOverride(*args)

def SoOverrideElement_setColorIndexOverride(*args):
  """SoOverrideElement_setColorIndexOverride(SoState state, SoNode node, SbBool override)"""
  return _coin.SoOverrideElement_setColorIndexOverride(*args)

def SoOverrideElement_setComplexityOverride(*args):
  """SoOverrideElement_setComplexityOverride(SoState state, SoNode node, SbBool override)"""
  return _coin.SoOverrideElement_setComplexityOverride(*args)

def SoOverrideElement_setComplexityTypeOverride(*args):
  """SoOverrideElement_setComplexityTypeOverride(SoState state, SoNode node, SbBool override)"""
  return _coin.SoOverrideElement_setComplexityTypeOverride(*args)

def SoOverrideElement_setCreaseAngleOverride(*args):
  """SoOverrideElement_setCreaseAngleOverride(SoState state, SoNode node, SbBool override)"""
  return _coin.SoOverrideElement_setCreaseAngleOverride(*args)

def SoOverrideElement_setDiffuseColorOverride(*args):
  """SoOverrideElement_setDiffuseColorOverride(SoState state, SoNode node, SbBool override)"""
  return _coin.SoOverrideElement_setDiffuseColorOverride(*args)

def SoOverrideElement_setDrawStyleOverride(*args):
  """SoOverrideElement_setDrawStyleOverride(SoState state, SoNode node, SbBool override)"""
  return _coin.SoOverrideElement_setDrawStyleOverride(*args)

def SoOverrideElement_setEmissiveColorOverride(*args):
  """SoOverrideElement_setEmissiveColorOverride(SoState state, SoNode node, SbBool override)"""
  return _coin.SoOverrideElement_setEmissiveColorOverride(*args)

def SoOverrideElement_setFontNameOverride(*args):
  """SoOverrideElement_setFontNameOverride(SoState state, SoNode node, SbBool override)"""
  return _coin.SoOverrideElement_setFontNameOverride(*args)

def SoOverrideElement_setFontSizeOverride(*args):
  """SoOverrideElement_setFontSizeOverride(SoState state, SoNode node, SbBool override)"""
  return _coin.SoOverrideElement_setFontSizeOverride(*args)

def SoOverrideElement_setLightModelOverride(*args):
  """SoOverrideElement_setLightModelOverride(SoState state, SoNode node, SbBool override)"""
  return _coin.SoOverrideElement_setLightModelOverride(*args)

def SoOverrideElement_setLinePatternOverride(*args):
  """SoOverrideElement_setLinePatternOverride(SoState state, SoNode node, SbBool override)"""
  return _coin.SoOverrideElement_setLinePatternOverride(*args)

def SoOverrideElement_setLineWidthOverride(*args):
  """SoOverrideElement_setLineWidthOverride(SoState state, SoNode node, SbBool override)"""
  return _coin.SoOverrideElement_setLineWidthOverride(*args)

def SoOverrideElement_setMaterialBindingOverride(*args):
  """SoOverrideElement_setMaterialBindingOverride(SoState state, SoNode node, SbBool override)"""
  return _coin.SoOverrideElement_setMaterialBindingOverride(*args)

def SoOverrideElement_setPickStyleOverride(*args):
  """SoOverrideElement_setPickStyleOverride(SoState state, SoNode node, SbBool override)"""
  return _coin.SoOverrideElement_setPickStyleOverride(*args)

def SoOverrideElement_setPointSizeOverride(*args):
  """SoOverrideElement_setPointSizeOverride(SoState state, SoNode node, SbBool override)"""
  return _coin.SoOverrideElement_setPointSizeOverride(*args)

def SoOverrideElement_setPolygonOffsetOverride(*args):
  """SoOverrideElement_setPolygonOffsetOverride(SoState state, SoNode node, SbBool override)"""
  return _coin.SoOverrideElement_setPolygonOffsetOverride(*args)

def SoOverrideElement_setShapeHintsOverride(*args):
  """SoOverrideElement_setShapeHintsOverride(SoState state, SoNode node, SbBool override)"""
  return _coin.SoOverrideElement_setShapeHintsOverride(*args)

def SoOverrideElement_setShininessOverride(*args):
  """SoOverrideElement_setShininessOverride(SoState state, SoNode node, SbBool override)"""
  return _coin.SoOverrideElement_setShininessOverride(*args)

def SoOverrideElement_setSpecularColorOverride(*args):
  """SoOverrideElement_setSpecularColorOverride(SoState state, SoNode node, SbBool override)"""
  return _coin.SoOverrideElement_setSpecularColorOverride(*args)

def SoOverrideElement_setTransparencyOverride(*args):
  """SoOverrideElement_setTransparencyOverride(SoState state, SoNode node, SbBool override)"""
  return _coin.SoOverrideElement_setTransparencyOverride(*args)

def SoOverrideElement_setTransparencyTypeOverride(*args):
  """SoOverrideElement_setTransparencyTypeOverride(SoState state, SoNode node, SbBool override)"""
  return _coin.SoOverrideElement_setTransparencyTypeOverride(*args)

def SoOverrideElement_setNormalVectorOverride(*args):
  """SoOverrideElement_setNormalVectorOverride(SoState state, SoNode node, SbBool override)"""
  return _coin.SoOverrideElement_setNormalVectorOverride(*args)

def SoOverrideElement_setNormalBindingOverride(*args):
  """SoOverrideElement_setNormalBindingOverride(SoState state, SoNode node, SbBool override)"""
  return _coin.SoOverrideElement_setNormalBindingOverride(*args)

class SoPickRayElement(SoElement):
    """Proxy of C++ SoPickRayElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoPickRayElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoPickRayElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoPickRayElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoPickRayElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoPickRayElement_init(self, *args)

    def matches(self, *args):
        """matches(self, SoElement element) -> SbBool"""
        return _coin.SoPickRayElement_matches(self, *args)

    def copyMatchInfo(self):
        """copyMatchInfo(self) -> SoElement"""
        return _coin.SoPickRayElement_copyMatchInfo(self)

    def set(*args):
        """set(SoState state, SbViewVolume volume)"""
        return _coin.SoPickRayElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> SbViewVolume"""
        return _coin.SoPickRayElement_get(*args)

    get = staticmethod(get)
SoPickRayElement_swigregister = _coin.SoPickRayElement_swigregister
SoPickRayElement_swigregister(SoPickRayElement)

def SoPickRayElement_getClassTypeId():
  """SoPickRayElement_getClassTypeId() -> SoType"""
  return _coin.SoPickRayElement_getClassTypeId()

def SoPickRayElement_getClassStackIndex():
  """SoPickRayElement_getClassStackIndex() -> int"""
  return _coin.SoPickRayElement_getClassStackIndex()

def SoPickRayElement_createInstance():
  """SoPickRayElement_createInstance() -> void"""
  return _coin.SoPickRayElement_createInstance()

def SoPickRayElement_initClass():
  """SoPickRayElement_initClass()"""
  return _coin.SoPickRayElement_initClass()

def SoPickRayElement_set(*args):
  """SoPickRayElement_set(SoState state, SbViewVolume volume)"""
  return _coin.SoPickRayElement_set(*args)

def SoPickRayElement_get(*args):
  """SoPickRayElement_get(SoState state) -> SbViewVolume"""
  return _coin.SoPickRayElement_get(*args)

class SoGLCoordinateElement(SoCoordinateElement):
    """Proxy of C++ SoGLCoordinateElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLCoordinateElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLCoordinateElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLCoordinateElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLCoordinateElement_initClass()

    initClass = staticmethod(initClass)
    def getPtr3(self):
        """getPtr3(self) -> SbVec3f"""
        return _coin.SoGLCoordinateElement_getPtr3(self)

    def getPtr4(self):
        """getPtr4(self) -> SbVec4f"""
        return _coin.SoGLCoordinateElement_getPtr4(self)

    def send(self, *args):
        """send(self, int index)"""
        return _coin.SoGLCoordinateElement_send(self, *args)

SoGLCoordinateElement_swigregister = _coin.SoGLCoordinateElement_swigregister
SoGLCoordinateElement_swigregister(SoGLCoordinateElement)

def SoGLCoordinateElement_getClassTypeId():
  """SoGLCoordinateElement_getClassTypeId() -> SoType"""
  return _coin.SoGLCoordinateElement_getClassTypeId()

def SoGLCoordinateElement_getClassStackIndex():
  """SoGLCoordinateElement_getClassStackIndex() -> int"""
  return _coin.SoGLCoordinateElement_getClassStackIndex()

def SoGLCoordinateElement_createInstance():
  """SoGLCoordinateElement_createInstance() -> void"""
  return _coin.SoGLCoordinateElement_createInstance()

def SoGLCoordinateElement_initClass():
  """SoGLCoordinateElement_initClass()"""
  return _coin.SoGLCoordinateElement_initClass()

class SoEnvironmentElement(SoReplacedElement):
    """Proxy of C++ SoEnvironmentElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoEnvironmentElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoEnvironmentElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoEnvironmentElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoEnvironmentElement_initClass()

    initClass = staticmethod(initClass)
    NONE = _coin.SoEnvironmentElement_NONE
    HAZE = _coin.SoEnvironmentElement_HAZE
    FOG = _coin.SoEnvironmentElement_FOG
    SMOKE = _coin.SoEnvironmentElement_SMOKE
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoEnvironmentElement_init(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, float ambientIntensity, 
            SbColor ambientColor, SbVec3f attenuation, int32_t fogType, 
            SbColor fogColor, float fogVisibility, 
            float fogStart = 0.0)
        set(SoState state, SoNode node, float ambientIntensity, 
            SbColor ambientColor, SbVec3f attenuation, int32_t fogType, 
            SbColor fogColor, float fogVisibility)
        """
        return _coin.SoEnvironmentElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """
        get(SoState state, float ambientIntensity, SbColor ambientColor, 
            SbVec3f attenuation, int32_t fogType, 
            SbColor fogColor, float fogVisibility, float fogStart)
        """
        return _coin.SoEnvironmentElement_get(*args)

    get = staticmethod(get)
    def getAmbientIntensity(*args):
        """getAmbientIntensity(SoState state) -> float"""
        return _coin.SoEnvironmentElement_getAmbientIntensity(*args)

    getAmbientIntensity = staticmethod(getAmbientIntensity)
    def getFogVisibility(*args):
        """getFogVisibility(SoState state) -> float"""
        return _coin.SoEnvironmentElement_getFogVisibility(*args)

    getFogVisibility = staticmethod(getFogVisibility)
    def getLightAttenuation(*args):
        """getLightAttenuation(SoState state) -> SbVec3f"""
        return _coin.SoEnvironmentElement_getLightAttenuation(*args)

    getLightAttenuation = staticmethod(getLightAttenuation)
    def getAmbientColor(*args):
        """getAmbientColor(SoState state) -> SbColor"""
        return _coin.SoEnvironmentElement_getAmbientColor(*args)

    getAmbientColor = staticmethod(getAmbientColor)
    def getFogColor(*args):
        """getFogColor(SoState state) -> SbColor"""
        return _coin.SoEnvironmentElement_getFogColor(*args)

    getFogColor = staticmethod(getFogColor)
    def getFogType(*args):
        """getFogType(SoState state) -> int32_t"""
        return _coin.SoEnvironmentElement_getFogType(*args)

    getFogType = staticmethod(getFogType)
    def getDefault(*args):
        """
        getDefault(float ambientIntensity, SbColor ambientColor, SbVec3f attenuation, 
            int32_t fogType, SbColor fogColor, 
            float fogVisibility, float fogNear)
        """
        return _coin.SoEnvironmentElement_getDefault(*args)

    getDefault = staticmethod(getDefault)
    def output(self, *args):
        """output(self, FILE file)"""
        return _coin.SoEnvironmentElement_output(self, *args)

SoEnvironmentElement_swigregister = _coin.SoEnvironmentElement_swigregister
SoEnvironmentElement_swigregister(SoEnvironmentElement)

def SoEnvironmentElement_getClassTypeId():
  """SoEnvironmentElement_getClassTypeId() -> SoType"""
  return _coin.SoEnvironmentElement_getClassTypeId()

def SoEnvironmentElement_getClassStackIndex():
  """SoEnvironmentElement_getClassStackIndex() -> int"""
  return _coin.SoEnvironmentElement_getClassStackIndex()

def SoEnvironmentElement_createInstance():
  """SoEnvironmentElement_createInstance() -> void"""
  return _coin.SoEnvironmentElement_createInstance()

def SoEnvironmentElement_initClass():
  """SoEnvironmentElement_initClass()"""
  return _coin.SoEnvironmentElement_initClass()

def SoEnvironmentElement_set(*args):
  """
    set(SoState state, SoNode node, float ambientIntensity, 
        SbColor ambientColor, SbVec3f attenuation, int32_t fogType, 
        SbColor fogColor, float fogVisibility, 
        float fogStart = 0.0)
    SoEnvironmentElement_set(SoState state, SoNode node, float ambientIntensity, 
        SbColor ambientColor, SbVec3f attenuation, int32_t fogType, 
        SbColor fogColor, float fogVisibility)
    """
  return _coin.SoEnvironmentElement_set(*args)

def SoEnvironmentElement_get(*args):
  """
    SoEnvironmentElement_get(SoState state, float ambientIntensity, SbColor ambientColor, 
        SbVec3f attenuation, int32_t fogType, 
        SbColor fogColor, float fogVisibility, float fogStart)
    """
  return _coin.SoEnvironmentElement_get(*args)

def SoEnvironmentElement_getAmbientIntensity(*args):
  """SoEnvironmentElement_getAmbientIntensity(SoState state) -> float"""
  return _coin.SoEnvironmentElement_getAmbientIntensity(*args)

def SoEnvironmentElement_getFogVisibility(*args):
  """SoEnvironmentElement_getFogVisibility(SoState state) -> float"""
  return _coin.SoEnvironmentElement_getFogVisibility(*args)

def SoEnvironmentElement_getLightAttenuation(*args):
  """SoEnvironmentElement_getLightAttenuation(SoState state) -> SbVec3f"""
  return _coin.SoEnvironmentElement_getLightAttenuation(*args)

def SoEnvironmentElement_getAmbientColor(*args):
  """SoEnvironmentElement_getAmbientColor(SoState state) -> SbColor"""
  return _coin.SoEnvironmentElement_getAmbientColor(*args)

def SoEnvironmentElement_getFogColor(*args):
  """SoEnvironmentElement_getFogColor(SoState state) -> SbColor"""
  return _coin.SoEnvironmentElement_getFogColor(*args)

def SoEnvironmentElement_getFogType(*args):
  """SoEnvironmentElement_getFogType(SoState state) -> int32_t"""
  return _coin.SoEnvironmentElement_getFogType(*args)

def SoEnvironmentElement_getDefault(*args):
  """
    SoEnvironmentElement_getDefault(float ambientIntensity, SbColor ambientColor, SbVec3f attenuation, 
        int32_t fogType, SbColor fogColor, 
        float fogVisibility, float fogNear)
    """
  return _coin.SoEnvironmentElement_getDefault(*args)

class SoGLEnvironmentElement(SoEnvironmentElement):
    """Proxy of C++ SoGLEnvironmentElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLEnvironmentElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLEnvironmentElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLEnvironmentElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLEnvironmentElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLEnvironmentElement_init(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLEnvironmentElement_pop(self, *args)

SoGLEnvironmentElement_swigregister = _coin.SoGLEnvironmentElement_swigregister
SoGLEnvironmentElement_swigregister(SoGLEnvironmentElement)

def SoGLEnvironmentElement_getClassTypeId():
  """SoGLEnvironmentElement_getClassTypeId() -> SoType"""
  return _coin.SoGLEnvironmentElement_getClassTypeId()

def SoGLEnvironmentElement_getClassStackIndex():
  """SoGLEnvironmentElement_getClassStackIndex() -> int"""
  return _coin.SoGLEnvironmentElement_getClassStackIndex()

def SoGLEnvironmentElement_createInstance():
  """SoGLEnvironmentElement_createInstance() -> void"""
  return _coin.SoGLEnvironmentElement_createInstance()

def SoGLEnvironmentElement_initClass():
  """SoGLEnvironmentElement_initClass()"""
  return _coin.SoGLEnvironmentElement_initClass()

class SoFontNameElement(SoReplacedElement):
    """Proxy of C++ SoFontNameElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoFontNameElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoFontNameElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoFontNameElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoFontNameElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoFontNameElement_init(self, *args)

    def set(*args):
        """set(SoState state, SoNode node, SbName fontName)"""
        return _coin.SoFontNameElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> SbName"""
        return _coin.SoFontNameElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> SbName"""
        return _coin.SoFontNameElement_getDefault()

    getDefault = staticmethod(getDefault)
    def matches(self, *args):
        """matches(self, SoElement element) -> SbBool"""
        return _coin.SoFontNameElement_matches(self, *args)

    def copyMatchInfo(self):
        """copyMatchInfo(self) -> SoElement"""
        return _coin.SoFontNameElement_copyMatchInfo(self)

    def output(self, *args):
        """output(self, FILE file)"""
        return _coin.SoFontNameElement_output(self, *args)

SoFontNameElement_swigregister = _coin.SoFontNameElement_swigregister
SoFontNameElement_swigregister(SoFontNameElement)

def SoFontNameElement_getClassTypeId():
  """SoFontNameElement_getClassTypeId() -> SoType"""
  return _coin.SoFontNameElement_getClassTypeId()

def SoFontNameElement_getClassStackIndex():
  """SoFontNameElement_getClassStackIndex() -> int"""
  return _coin.SoFontNameElement_getClassStackIndex()

def SoFontNameElement_createInstance():
  """SoFontNameElement_createInstance() -> void"""
  return _coin.SoFontNameElement_createInstance()

def SoFontNameElement_initClass():
  """SoFontNameElement_initClass()"""
  return _coin.SoFontNameElement_initClass()

def SoFontNameElement_set(*args):
  """SoFontNameElement_set(SoState state, SoNode node, SbName fontName)"""
  return _coin.SoFontNameElement_set(*args)

def SoFontNameElement_get(*args):
  """SoFontNameElement_get(SoState state) -> SbName"""
  return _coin.SoFontNameElement_get(*args)

def SoFontNameElement_getDefault():
  """SoFontNameElement_getDefault() -> SbName"""
  return _coin.SoFontNameElement_getDefault()

class SoLightAttenuationElement(SoReplacedElement):
    """Proxy of C++ SoLightAttenuationElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoLightAttenuationElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoLightAttenuationElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoLightAttenuationElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoLightAttenuationElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoLightAttenuationElement_init(self, *args)

    def set(*args):
        """set(SoState state, SoNode node, SbVec3f lightAttenuation)"""
        return _coin.SoLightAttenuationElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> SbVec3f"""
        return _coin.SoLightAttenuationElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> SbVec3f"""
        return _coin.SoLightAttenuationElement_getDefault()

    getDefault = staticmethod(getDefault)
    def matches(self, *args):
        """matches(self, SoElement element) -> SbBool"""
        return _coin.SoLightAttenuationElement_matches(self, *args)

    def copyMatchInfo(self):
        """copyMatchInfo(self) -> SoElement"""
        return _coin.SoLightAttenuationElement_copyMatchInfo(self)

    def output(self, *args):
        """output(self, FILE file)"""
        return _coin.SoLightAttenuationElement_output(self, *args)

SoLightAttenuationElement_swigregister = _coin.SoLightAttenuationElement_swigregister
SoLightAttenuationElement_swigregister(SoLightAttenuationElement)

def SoLightAttenuationElement_getClassTypeId():
  """SoLightAttenuationElement_getClassTypeId() -> SoType"""
  return _coin.SoLightAttenuationElement_getClassTypeId()

def SoLightAttenuationElement_getClassStackIndex():
  """SoLightAttenuationElement_getClassStackIndex() -> int"""
  return _coin.SoLightAttenuationElement_getClassStackIndex()

def SoLightAttenuationElement_createInstance():
  """SoLightAttenuationElement_createInstance() -> void"""
  return _coin.SoLightAttenuationElement_createInstance()

def SoLightAttenuationElement_initClass():
  """SoLightAttenuationElement_initClass()"""
  return _coin.SoLightAttenuationElement_initClass()

def SoLightAttenuationElement_set(*args):
  """SoLightAttenuationElement_set(SoState state, SoNode node, SbVec3f lightAttenuation)"""
  return _coin.SoLightAttenuationElement_set(*args)

def SoLightAttenuationElement_get(*args):
  """SoLightAttenuationElement_get(SoState state) -> SbVec3f"""
  return _coin.SoLightAttenuationElement_get(*args)

def SoLightAttenuationElement_getDefault():
  """SoLightAttenuationElement_getDefault() -> SbVec3f"""
  return _coin.SoLightAttenuationElement_getDefault()

class SoPolygonOffsetElement(SoReplacedElement):
    """Proxy of C++ SoPolygonOffsetElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoPolygonOffsetElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoPolygonOffsetElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoPolygonOffsetElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoPolygonOffsetElement_initClass()

    initClass = staticmethod(initClass)
    FILLED = _coin.SoPolygonOffsetElement_FILLED
    LINES = _coin.SoPolygonOffsetElement_LINES
    POINTS = _coin.SoPolygonOffsetElement_POINTS
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoPolygonOffsetElement_init(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, float factor, float units, 
            Style styles, SbBool on)
        """
        return _coin.SoPolygonOffsetElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """
        get(SoState state, float factor, float units, Style styles, 
            SbBool on)
        """
        return _coin.SoPolygonOffsetElement_get(*args)

    get = staticmethod(get)
    def getDefault(*args):
        """getDefault(float factor, float units, Style styles, SbBool on)"""
        return _coin.SoPolygonOffsetElement_getDefault(*args)

    getDefault = staticmethod(getDefault)
SoPolygonOffsetElement_swigregister = _coin.SoPolygonOffsetElement_swigregister
SoPolygonOffsetElement_swigregister(SoPolygonOffsetElement)

def SoPolygonOffsetElement_getClassTypeId():
  """SoPolygonOffsetElement_getClassTypeId() -> SoType"""
  return _coin.SoPolygonOffsetElement_getClassTypeId()

def SoPolygonOffsetElement_getClassStackIndex():
  """SoPolygonOffsetElement_getClassStackIndex() -> int"""
  return _coin.SoPolygonOffsetElement_getClassStackIndex()

def SoPolygonOffsetElement_createInstance():
  """SoPolygonOffsetElement_createInstance() -> void"""
  return _coin.SoPolygonOffsetElement_createInstance()

def SoPolygonOffsetElement_initClass():
  """SoPolygonOffsetElement_initClass()"""
  return _coin.SoPolygonOffsetElement_initClass()

def SoPolygonOffsetElement_set(*args):
  """
    SoPolygonOffsetElement_set(SoState state, SoNode node, float factor, float units, 
        Style styles, SbBool on)
    """
  return _coin.SoPolygonOffsetElement_set(*args)

def SoPolygonOffsetElement_get(*args):
  """
    SoPolygonOffsetElement_get(SoState state, float factor, float units, Style styles, 
        SbBool on)
    """
  return _coin.SoPolygonOffsetElement_get(*args)

def SoPolygonOffsetElement_getDefault(*args):
  """SoPolygonOffsetElement_getDefault(float factor, float units, Style styles, SbBool on)"""
  return _coin.SoPolygonOffsetElement_getDefault(*args)

class SoGLPolygonOffsetElement(SoPolygonOffsetElement):
    """Proxy of C++ SoGLPolygonOffsetElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLPolygonOffsetElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLPolygonOffsetElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLPolygonOffsetElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLPolygonOffsetElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLPolygonOffsetElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoGLPolygonOffsetElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLPolygonOffsetElement_pop(self, *args)

SoGLPolygonOffsetElement_swigregister = _coin.SoGLPolygonOffsetElement_swigregister
SoGLPolygonOffsetElement_swigregister(SoGLPolygonOffsetElement)

def SoGLPolygonOffsetElement_getClassTypeId():
  """SoGLPolygonOffsetElement_getClassTypeId() -> SoType"""
  return _coin.SoGLPolygonOffsetElement_getClassTypeId()

def SoGLPolygonOffsetElement_getClassStackIndex():
  """SoGLPolygonOffsetElement_getClassStackIndex() -> int"""
  return _coin.SoGLPolygonOffsetElement_getClassStackIndex()

def SoGLPolygonOffsetElement_createInstance():
  """SoGLPolygonOffsetElement_createInstance() -> void"""
  return _coin.SoGLPolygonOffsetElement_createInstance()

def SoGLPolygonOffsetElement_initClass():
  """SoGLPolygonOffsetElement_initClass()"""
  return _coin.SoGLPolygonOffsetElement_initClass()

class SoProjectionMatrixElement(SoReplacedElement):
    """Proxy of C++ SoProjectionMatrixElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoProjectionMatrixElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoProjectionMatrixElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoProjectionMatrixElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoProjectionMatrixElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoProjectionMatrixElement_init(self, *args)

    def set(*args):
        """set(SoState state, SoNode node)"""
        return _coin.SoProjectionMatrixElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> SbMatrix"""
        return _coin.SoProjectionMatrixElement_get(*args)

    get = staticmethod(get)
SoProjectionMatrixElement_swigregister = _coin.SoProjectionMatrixElement_swigregister
SoProjectionMatrixElement_swigregister(SoProjectionMatrixElement)

def SoProjectionMatrixElement_getClassTypeId():
  """SoProjectionMatrixElement_getClassTypeId() -> SoType"""
  return _coin.SoProjectionMatrixElement_getClassTypeId()

def SoProjectionMatrixElement_getClassStackIndex():
  """SoProjectionMatrixElement_getClassStackIndex() -> int"""
  return _coin.SoProjectionMatrixElement_getClassStackIndex()

def SoProjectionMatrixElement_createInstance():
  """SoProjectionMatrixElement_createInstance() -> void"""
  return _coin.SoProjectionMatrixElement_createInstance()

def SoProjectionMatrixElement_initClass():
  """SoProjectionMatrixElement_initClass()"""
  return _coin.SoProjectionMatrixElement_initClass()

def SoProjectionMatrixElement_set(*args):
  """SoProjectionMatrixElement_set(SoState state, SoNode node)"""
  return _coin.SoProjectionMatrixElement_set(*args)

def SoProjectionMatrixElement_get(*args):
  """SoProjectionMatrixElement_get(SoState state) -> SbMatrix"""
  return _coin.SoProjectionMatrixElement_get(*args)

class SoGLProjectionMatrixElement(SoProjectionMatrixElement):
    """Proxy of C++ SoGLProjectionMatrixElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLProjectionMatrixElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLProjectionMatrixElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLProjectionMatrixElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLProjectionMatrixElement_initClass()

    initClass = staticmethod(initClass)
    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLProjectionMatrixElement_pop(self, *args)

SoGLProjectionMatrixElement_swigregister = _coin.SoGLProjectionMatrixElement_swigregister
SoGLProjectionMatrixElement_swigregister(SoGLProjectionMatrixElement)

def SoGLProjectionMatrixElement_getClassTypeId():
  """SoGLProjectionMatrixElement_getClassTypeId() -> SoType"""
  return _coin.SoGLProjectionMatrixElement_getClassTypeId()

def SoGLProjectionMatrixElement_getClassStackIndex():
  """SoGLProjectionMatrixElement_getClassStackIndex() -> int"""
  return _coin.SoGLProjectionMatrixElement_getClassStackIndex()

def SoGLProjectionMatrixElement_createInstance():
  """SoGLProjectionMatrixElement_createInstance() -> void"""
  return _coin.SoGLProjectionMatrixElement_createInstance()

def SoGLProjectionMatrixElement_initClass():
  """SoGLProjectionMatrixElement_initClass()"""
  return _coin.SoGLProjectionMatrixElement_initClass()

class SoProfileCoordinateElement(SoReplacedElement):
    """Proxy of C++ SoProfileCoordinateElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoProfileCoordinateElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoProfileCoordinateElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoProfileCoordinateElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoProfileCoordinateElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoProfileCoordinateElement_init(self, *args)

    def set2(*args):
        """set2(SoState state, SoNode node, int32_t numCoords, SbVec2f coords)"""
        return _coin.SoProfileCoordinateElement_set2(*args)

    set2 = staticmethod(set2)
    def set3(*args):
        """set3(SoState state, SoNode node, int32_t numCoords, SbVec3f coords)"""
        return _coin.SoProfileCoordinateElement_set3(*args)

    set3 = staticmethod(set3)
    def getInstance(*args):
        """getInstance(SoState state) -> SoProfileCoordinateElement"""
        return _coin.SoProfileCoordinateElement_getInstance(*args)

    getInstance = staticmethod(getInstance)
    def getNum(self):
        """getNum(self) -> int32_t"""
        return _coin.SoProfileCoordinateElement_getNum(self)

    def get2(self, *args):
        """get2(self, int index) -> SbVec2f"""
        return _coin.SoProfileCoordinateElement_get2(self, *args)

    def get3(self, *args):
        """get3(self, int index) -> SbVec3f"""
        return _coin.SoProfileCoordinateElement_get3(self, *args)

    def is2D(self):
        """is2D(self) -> SbBool"""
        return _coin.SoProfileCoordinateElement_is2D(self)

    def getDefault2():
        """getDefault2() -> SbVec2f"""
        return _coin.SoProfileCoordinateElement_getDefault2()

    getDefault2 = staticmethod(getDefault2)
    def getDefault3():
        """getDefault3() -> SbVec3f"""
        return _coin.SoProfileCoordinateElement_getDefault3()

    getDefault3 = staticmethod(getDefault3)
    def getArrayPtr2(self):
        """getArrayPtr2(self) -> SbVec2f"""
        return _coin.SoProfileCoordinateElement_getArrayPtr2(self)

    def getArrayPtr3(self):
        """getArrayPtr3(self) -> SbVec3f"""
        return _coin.SoProfileCoordinateElement_getArrayPtr3(self)

SoProfileCoordinateElement_swigregister = _coin.SoProfileCoordinateElement_swigregister
SoProfileCoordinateElement_swigregister(SoProfileCoordinateElement)

def SoProfileCoordinateElement_getClassTypeId():
  """SoProfileCoordinateElement_getClassTypeId() -> SoType"""
  return _coin.SoProfileCoordinateElement_getClassTypeId()

def SoProfileCoordinateElement_getClassStackIndex():
  """SoProfileCoordinateElement_getClassStackIndex() -> int"""
  return _coin.SoProfileCoordinateElement_getClassStackIndex()

def SoProfileCoordinateElement_createInstance():
  """SoProfileCoordinateElement_createInstance() -> void"""
  return _coin.SoProfileCoordinateElement_createInstance()

def SoProfileCoordinateElement_initClass():
  """SoProfileCoordinateElement_initClass()"""
  return _coin.SoProfileCoordinateElement_initClass()

def SoProfileCoordinateElement_set2(*args):
  """SoProfileCoordinateElement_set2(SoState state, SoNode node, int32_t numCoords, SbVec2f coords)"""
  return _coin.SoProfileCoordinateElement_set2(*args)

def SoProfileCoordinateElement_set3(*args):
  """SoProfileCoordinateElement_set3(SoState state, SoNode node, int32_t numCoords, SbVec3f coords)"""
  return _coin.SoProfileCoordinateElement_set3(*args)

def SoProfileCoordinateElement_getInstance(*args):
  """SoProfileCoordinateElement_getInstance(SoState state) -> SoProfileCoordinateElement"""
  return _coin.SoProfileCoordinateElement_getInstance(*args)

def SoProfileCoordinateElement_getDefault2():
  """SoProfileCoordinateElement_getDefault2() -> SbVec2f"""
  return _coin.SoProfileCoordinateElement_getDefault2()

def SoProfileCoordinateElement_getDefault3():
  """SoProfileCoordinateElement_getDefault3() -> SbVec3f"""
  return _coin.SoProfileCoordinateElement_getDefault3()

class SoGLTextureImageElement(SoTextureImageElement):
    """Proxy of C++ SoGLTextureImageElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLTextureImageElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLTextureImageElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLTextureImageElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLTextureImageElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLTextureImageElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoGLTextureImageElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLTextureImageElement_pop(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, SoGLImage image, Model model, 
            SbColor blendColor)
        """
        return _coin.SoGLTextureImageElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state, Model model, SbColor blendcolor) -> SoGLImage"""
        return _coin.SoGLTextureImageElement_get(*args)

    get = staticmethod(get)
    def getMaxGLTextureSize():
        """getMaxGLTextureSize() -> int32_t"""
        return _coin.SoGLTextureImageElement_getMaxGLTextureSize()

    getMaxGLTextureSize = staticmethod(getMaxGLTextureSize)
    def isTextureSizeLegal(self, *args):
        """isTextureSizeLegal(self, int xsize, int ysize, int zsize, int bytespertexel) -> SbBool"""
        return _coin.SoGLTextureImageElement_isTextureSizeLegal(self, *args)

    def hasTransparency(*args):
        """hasTransparency(SoState state) -> SbBool"""
        return _coin.SoGLTextureImageElement_hasTransparency(*args)

    hasTransparency = staticmethod(hasTransparency)
SoGLTextureImageElement_swigregister = _coin.SoGLTextureImageElement_swigregister
SoGLTextureImageElement_swigregister(SoGLTextureImageElement)

def SoGLTextureImageElement_getClassTypeId():
  """SoGLTextureImageElement_getClassTypeId() -> SoType"""
  return _coin.SoGLTextureImageElement_getClassTypeId()

def SoGLTextureImageElement_getClassStackIndex():
  """SoGLTextureImageElement_getClassStackIndex() -> int"""
  return _coin.SoGLTextureImageElement_getClassStackIndex()

def SoGLTextureImageElement_createInstance():
  """SoGLTextureImageElement_createInstance() -> void"""
  return _coin.SoGLTextureImageElement_createInstance()

def SoGLTextureImageElement_initClass():
  """SoGLTextureImageElement_initClass()"""
  return _coin.SoGLTextureImageElement_initClass()

def SoGLTextureImageElement_set(*args):
  """
    SoGLTextureImageElement_set(SoState state, SoNode node, SoGLImage image, Model model, 
        SbColor blendColor)
    """
  return _coin.SoGLTextureImageElement_set(*args)

def SoGLTextureImageElement_get(*args):
  """SoGLTextureImageElement_get(SoState state, Model model, SbColor blendcolor) -> SoGLImage"""
  return _coin.SoGLTextureImageElement_get(*args)

def SoGLTextureImageElement_getMaxGLTextureSize():
  """SoGLTextureImageElement_getMaxGLTextureSize() -> int32_t"""
  return _coin.SoGLTextureImageElement_getMaxGLTextureSize()

def SoGLTextureImageElement_hasTransparency(*args):
  """SoGLTextureImageElement_hasTransparency(SoState state) -> SbBool"""
  return _coin.SoGLTextureImageElement_hasTransparency(*args)

class SoViewingMatrixElement(SoReplacedElement):
    """Proxy of C++ SoViewingMatrixElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoViewingMatrixElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoViewingMatrixElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoViewingMatrixElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoViewingMatrixElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoViewingMatrixElement_init(self, *args)

    def set(*args):
        """set(SoState state, SoNode node, SbMatrix ViewingMatrix)"""
        return _coin.SoViewingMatrixElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> SbMatrix"""
        return _coin.SoViewingMatrixElement_get(*args)

    get = staticmethod(get)
SoViewingMatrixElement_swigregister = _coin.SoViewingMatrixElement_swigregister
SoViewingMatrixElement_swigregister(SoViewingMatrixElement)

def SoViewingMatrixElement_getClassTypeId():
  """SoViewingMatrixElement_getClassTypeId() -> SoType"""
  return _coin.SoViewingMatrixElement_getClassTypeId()

def SoViewingMatrixElement_getClassStackIndex():
  """SoViewingMatrixElement_getClassStackIndex() -> int"""
  return _coin.SoViewingMatrixElement_getClassStackIndex()

def SoViewingMatrixElement_createInstance():
  """SoViewingMatrixElement_createInstance() -> void"""
  return _coin.SoViewingMatrixElement_createInstance()

def SoViewingMatrixElement_initClass():
  """SoViewingMatrixElement_initClass()"""
  return _coin.SoViewingMatrixElement_initClass()

def SoViewingMatrixElement_set(*args):
  """SoViewingMatrixElement_set(SoState state, SoNode node, SbMatrix ViewingMatrix)"""
  return _coin.SoViewingMatrixElement_set(*args)

def SoViewingMatrixElement_get(*args):
  """SoViewingMatrixElement_get(SoState state) -> SbMatrix"""
  return _coin.SoViewingMatrixElement_get(*args)

class SoGLViewingMatrixElement(SoViewingMatrixElement):
    """Proxy of C++ SoGLViewingMatrixElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLViewingMatrixElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLViewingMatrixElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLViewingMatrixElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLViewingMatrixElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLViewingMatrixElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoGLViewingMatrixElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLViewingMatrixElement_pop(self, *args)

    def getNodeId(*args):
        """getNodeId(SoState state) -> uint32_t"""
        return _coin.SoGLViewingMatrixElement_getNodeId(*args)

    getNodeId = staticmethod(getNodeId)
    def getResetMatrix(*args):
        """getResetMatrix(SoState state) -> SbMatrix"""
        return _coin.SoGLViewingMatrixElement_getResetMatrix(*args)

    getResetMatrix = staticmethod(getResetMatrix)
SoGLViewingMatrixElement_swigregister = _coin.SoGLViewingMatrixElement_swigregister
SoGLViewingMatrixElement_swigregister(SoGLViewingMatrixElement)

def SoGLViewingMatrixElement_getClassTypeId():
  """SoGLViewingMatrixElement_getClassTypeId() -> SoType"""
  return _coin.SoGLViewingMatrixElement_getClassTypeId()

def SoGLViewingMatrixElement_getClassStackIndex():
  """SoGLViewingMatrixElement_getClassStackIndex() -> int"""
  return _coin.SoGLViewingMatrixElement_getClassStackIndex()

def SoGLViewingMatrixElement_createInstance():
  """SoGLViewingMatrixElement_createInstance() -> void"""
  return _coin.SoGLViewingMatrixElement_createInstance()

def SoGLViewingMatrixElement_initClass():
  """SoGLViewingMatrixElement_initClass()"""
  return _coin.SoGLViewingMatrixElement_initClass()

def SoGLViewingMatrixElement_getNodeId(*args):
  """SoGLViewingMatrixElement_getNodeId(SoState state) -> uint32_t"""
  return _coin.SoGLViewingMatrixElement_getNodeId(*args)

def SoGLViewingMatrixElement_getResetMatrix(*args):
  """SoGLViewingMatrixElement_getResetMatrix(SoState state) -> SbMatrix"""
  return _coin.SoGLViewingMatrixElement_getResetMatrix(*args)

class SoViewVolumeElement(SoReplacedElement):
    """Proxy of C++ SoViewVolumeElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoViewVolumeElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoViewVolumeElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoViewVolumeElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoViewVolumeElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoViewVolumeElement_init(self, *args)

    def set(*args):
        """set(SoState state, SoNode node, SbViewVolume viewVolume)"""
        return _coin.SoViewVolumeElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> SbViewVolume"""
        return _coin.SoViewVolumeElement_get(*args)

    get = staticmethod(get)
SoViewVolumeElement_swigregister = _coin.SoViewVolumeElement_swigregister
SoViewVolumeElement_swigregister(SoViewVolumeElement)

def SoViewVolumeElement_getClassTypeId():
  """SoViewVolumeElement_getClassTypeId() -> SoType"""
  return _coin.SoViewVolumeElement_getClassTypeId()

def SoViewVolumeElement_getClassStackIndex():
  """SoViewVolumeElement_getClassStackIndex() -> int"""
  return _coin.SoViewVolumeElement_getClassStackIndex()

def SoViewVolumeElement_createInstance():
  """SoViewVolumeElement_createInstance() -> void"""
  return _coin.SoViewVolumeElement_createInstance()

def SoViewVolumeElement_initClass():
  """SoViewVolumeElement_initClass()"""
  return _coin.SoViewVolumeElement_initClass()

def SoViewVolumeElement_set(*args):
  """SoViewVolumeElement_set(SoState state, SoNode node, SbViewVolume viewVolume)"""
  return _coin.SoViewVolumeElement_set(*args)

def SoViewVolumeElement_get(*args):
  """SoViewVolumeElement_get(SoState state) -> SbViewVolume"""
  return _coin.SoViewVolumeElement_get(*args)

class SoGLShapeHintsElement(SoShapeHintsElement):
    """Proxy of C++ SoGLShapeHintsElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLShapeHintsElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLShapeHintsElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLShapeHintsElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLShapeHintsElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLShapeHintsElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoGLShapeHintsElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLShapeHintsElement_pop(self, *args)

    def forceSend(*args):
        """
        forceSend(SoState state, SbBool twoside)
        forceSend(SoState state, SbBool ccw, SbBool cull)
        forceSend(SoState state, SbBool ccw, SbBool cull, SbBool twoside)
        """
        return _coin.SoGLShapeHintsElement_forceSend(*args)

    forceSend = staticmethod(forceSend)
SoGLShapeHintsElement_swigregister = _coin.SoGLShapeHintsElement_swigregister
SoGLShapeHintsElement_swigregister(SoGLShapeHintsElement)

def SoGLShapeHintsElement_getClassTypeId():
  """SoGLShapeHintsElement_getClassTypeId() -> SoType"""
  return _coin.SoGLShapeHintsElement_getClassTypeId()

def SoGLShapeHintsElement_getClassStackIndex():
  """SoGLShapeHintsElement_getClassStackIndex() -> int"""
  return _coin.SoGLShapeHintsElement_getClassStackIndex()

def SoGLShapeHintsElement_createInstance():
  """SoGLShapeHintsElement_createInstance() -> void"""
  return _coin.SoGLShapeHintsElement_createInstance()

def SoGLShapeHintsElement_initClass():
  """SoGLShapeHintsElement_initClass()"""
  return _coin.SoGLShapeHintsElement_initClass()

def SoGLShapeHintsElement_forceSend(*args):
  """
    forceSend(SoState state, SbBool twoside)
    forceSend(SoState state, SbBool ccw, SbBool cull)
    SoGLShapeHintsElement_forceSend(SoState state, SbBool ccw, SbBool cull, SbBool twoside)
    """
  return _coin.SoGLShapeHintsElement_forceSend(*args)

class SoShapeStyleElement(SoElement):
    """Proxy of C++ SoShapeStyleElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShapeStyleElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoShapeStyleElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoShapeStyleElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoShapeStyleElement_initClass()

    initClass = staticmethod(initClass)
    LIGHTING = _coin.SoShapeStyleElement_LIGHTING
    TEXENABLED = _coin.SoShapeStyleElement_TEXENABLED
    TEXFUNC = _coin.SoShapeStyleElement_TEXFUNC
    BBOXCMPLX = _coin.SoShapeStyleElement_BBOXCMPLX
    INVISIBLE = _coin.SoShapeStyleElement_INVISIBLE
    ABORTCB = _coin.SoShapeStyleElement_ABORTCB
    OVERRIDE = _coin.SoShapeStyleElement_OVERRIDE
    TEX3ENABLED = _coin.SoShapeStyleElement_TEX3ENABLED
    BIGIMAGE = _coin.SoShapeStyleElement_BIGIMAGE
    BUMPMAP = _coin.SoShapeStyleElement_BUMPMAP
    VERTEXARRAY = _coin.SoShapeStyleElement_VERTEXARRAY
    TRANSP_TEXTURE = _coin.SoShapeStyleElement_TRANSP_TEXTURE
    TRANSP_MATERIAL = _coin.SoShapeStyleElement_TRANSP_MATERIAL
    TRANSP_SORTED_TRIANGLES = _coin.SoShapeStyleElement_TRANSP_SORTED_TRIANGLES
    SHADOWMAP = _coin.SoShapeStyleElement_SHADOWMAP
    SHADOWS = _coin.SoShapeStyleElement_SHADOWS
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoShapeStyleElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoShapeStyleElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoShapeStyleElement_pop(self, *args)

    def matches(self, *args):
        """matches(self, SoElement element) -> SbBool"""
        return _coin.SoShapeStyleElement_matches(self, *args)

    def copyMatchInfo(self):
        """copyMatchInfo(self) -> SoElement"""
        return _coin.SoShapeStyleElement_copyMatchInfo(self)

    def get(*args):
        """get(SoState state) -> SoShapeStyleElement"""
        return _coin.SoShapeStyleElement_get(*args)

    get = staticmethod(get)
    def getFlags(self):
        """getFlags(self) -> unsigned int"""
        return _coin.SoShapeStyleElement_getFlags(self)

    def mightNotRender(self):
        """mightNotRender(self) -> SbBool"""
        return _coin.SoShapeStyleElement_mightNotRender(self)

    def needNormals(self):
        """needNormals(self) -> SbBool"""
        return _coin.SoShapeStyleElement_needNormals(self)

    def needTexCoords(self):
        """needTexCoords(self) -> SbBool"""
        return _coin.SoShapeStyleElement_needTexCoords(self)

    def getRenderCaseMask(self):
        """getRenderCaseMask(self) -> int"""
        return _coin.SoShapeStyleElement_getRenderCaseMask(self)

    def setDrawStyle(*args):
        """setDrawStyle(SoState state, int32_t value)"""
        return _coin.SoShapeStyleElement_setDrawStyle(*args)

    setDrawStyle = staticmethod(setDrawStyle)
    def setComplexityType(*args):
        """setComplexityType(SoState state, int32_t value)"""
        return _coin.SoShapeStyleElement_setComplexityType(*args)

    setComplexityType = staticmethod(setComplexityType)
    def setTransparencyType(*args):
        """setTransparencyType(SoState state, int32_t value)"""
        return _coin.SoShapeStyleElement_setTransparencyType(*args)

    setTransparencyType = staticmethod(setTransparencyType)
    def setTextureEnabled(*args):
        """setTextureEnabled(SoState state, SbBool value)"""
        return _coin.SoShapeStyleElement_setTextureEnabled(*args)

    setTextureEnabled = staticmethod(setTextureEnabled)
    def setTexture3Enabled(*args):
        """setTexture3Enabled(SoState state, SbBool value)"""
        return _coin.SoShapeStyleElement_setTexture3Enabled(*args)

    setTexture3Enabled = staticmethod(setTexture3Enabled)
    def setTextureFunction(*args):
        """setTextureFunction(SoState state, SbBool value)"""
        return _coin.SoShapeStyleElement_setTextureFunction(*args)

    setTextureFunction = staticmethod(setTextureFunction)
    def setLightModel(*args):
        """setLightModel(SoState state, int32_t value)"""
        return _coin.SoShapeStyleElement_setLightModel(*args)

    setLightModel = staticmethod(setLightModel)
    def setOverrides(*args):
        """setOverrides(SoState state, SbBool value)"""
        return _coin.SoShapeStyleElement_setOverrides(*args)

    setOverrides = staticmethod(setOverrides)
    def isScreenDoor(*args):
        """isScreenDoor(SoState state) -> SbBool"""
        return _coin.SoShapeStyleElement_isScreenDoor(*args)

    isScreenDoor = staticmethod(isScreenDoor)
    def getTransparencyType(*args):
        """getTransparencyType(SoState state) -> int"""
        return _coin.SoShapeStyleElement_getTransparencyType(*args)

    getTransparencyType = staticmethod(getTransparencyType)
    def isTextureFunction(self):
        """isTextureFunction(self) -> SbBool"""
        return _coin.SoShapeStyleElement_isTextureFunction(self)

    def setBumpmapEnabled(*args):
        """setBumpmapEnabled(SoState state, SbBool value)"""
        return _coin.SoShapeStyleElement_setBumpmapEnabled(*args)

    setBumpmapEnabled = staticmethod(setBumpmapEnabled)
    def setBigImageEnabled(*args):
        """setBigImageEnabled(SoState state, SbBool value)"""
        return _coin.SoShapeStyleElement_setBigImageEnabled(*args)

    setBigImageEnabled = staticmethod(setBigImageEnabled)
    def setVertexArrayRendering(*args):
        """setVertexArrayRendering(SoState state, SbBool value)"""
        return _coin.SoShapeStyleElement_setVertexArrayRendering(*args)

    setVertexArrayRendering = staticmethod(setVertexArrayRendering)
    def setTransparentMaterial(*args):
        """setTransparentMaterial(SoState state, SbBool value)"""
        return _coin.SoShapeStyleElement_setTransparentMaterial(*args)

    setTransparentMaterial = staticmethod(setTransparentMaterial)
    def setTransparentTexture(*args):
        """setTransparentTexture(SoState state, SbBool value)"""
        return _coin.SoShapeStyleElement_setTransparentTexture(*args)

    setTransparentTexture = staticmethod(setTransparentTexture)
    def setShadowMapRendering(*args):
        """setShadowMapRendering(SoState state, SbBool value)"""
        return _coin.SoShapeStyleElement_setShadowMapRendering(*args)

    setShadowMapRendering = staticmethod(setShadowMapRendering)
    def setShadowsRendering(*args):
        """setShadowsRendering(SoState state, SbBool value)"""
        return _coin.SoShapeStyleElement_setShadowsRendering(*args)

    setShadowsRendering = staticmethod(setShadowsRendering)
SoShapeStyleElement_swigregister = _coin.SoShapeStyleElement_swigregister
SoShapeStyleElement_swigregister(SoShapeStyleElement)

def SoShapeStyleElement_getClassTypeId():
  """SoShapeStyleElement_getClassTypeId() -> SoType"""
  return _coin.SoShapeStyleElement_getClassTypeId()

def SoShapeStyleElement_getClassStackIndex():
  """SoShapeStyleElement_getClassStackIndex() -> int"""
  return _coin.SoShapeStyleElement_getClassStackIndex()

def SoShapeStyleElement_createInstance():
  """SoShapeStyleElement_createInstance() -> void"""
  return _coin.SoShapeStyleElement_createInstance()

def SoShapeStyleElement_initClass():
  """SoShapeStyleElement_initClass()"""
  return _coin.SoShapeStyleElement_initClass()

def SoShapeStyleElement_get(*args):
  """SoShapeStyleElement_get(SoState state) -> SoShapeStyleElement"""
  return _coin.SoShapeStyleElement_get(*args)

def SoShapeStyleElement_setDrawStyle(*args):
  """SoShapeStyleElement_setDrawStyle(SoState state, int32_t value)"""
  return _coin.SoShapeStyleElement_setDrawStyle(*args)

def SoShapeStyleElement_setComplexityType(*args):
  """SoShapeStyleElement_setComplexityType(SoState state, int32_t value)"""
  return _coin.SoShapeStyleElement_setComplexityType(*args)

def SoShapeStyleElement_setTransparencyType(*args):
  """SoShapeStyleElement_setTransparencyType(SoState state, int32_t value)"""
  return _coin.SoShapeStyleElement_setTransparencyType(*args)

def SoShapeStyleElement_setTextureEnabled(*args):
  """SoShapeStyleElement_setTextureEnabled(SoState state, SbBool value)"""
  return _coin.SoShapeStyleElement_setTextureEnabled(*args)

def SoShapeStyleElement_setTexture3Enabled(*args):
  """SoShapeStyleElement_setTexture3Enabled(SoState state, SbBool value)"""
  return _coin.SoShapeStyleElement_setTexture3Enabled(*args)

def SoShapeStyleElement_setTextureFunction(*args):
  """SoShapeStyleElement_setTextureFunction(SoState state, SbBool value)"""
  return _coin.SoShapeStyleElement_setTextureFunction(*args)

def SoShapeStyleElement_setLightModel(*args):
  """SoShapeStyleElement_setLightModel(SoState state, int32_t value)"""
  return _coin.SoShapeStyleElement_setLightModel(*args)

def SoShapeStyleElement_setOverrides(*args):
  """SoShapeStyleElement_setOverrides(SoState state, SbBool value)"""
  return _coin.SoShapeStyleElement_setOverrides(*args)

def SoShapeStyleElement_isScreenDoor(*args):
  """SoShapeStyleElement_isScreenDoor(SoState state) -> SbBool"""
  return _coin.SoShapeStyleElement_isScreenDoor(*args)

def SoShapeStyleElement_getTransparencyType(*args):
  """SoShapeStyleElement_getTransparencyType(SoState state) -> int"""
  return _coin.SoShapeStyleElement_getTransparencyType(*args)

def SoShapeStyleElement_setBumpmapEnabled(*args):
  """SoShapeStyleElement_setBumpmapEnabled(SoState state, SbBool value)"""
  return _coin.SoShapeStyleElement_setBumpmapEnabled(*args)

def SoShapeStyleElement_setBigImageEnabled(*args):
  """SoShapeStyleElement_setBigImageEnabled(SoState state, SbBool value)"""
  return _coin.SoShapeStyleElement_setBigImageEnabled(*args)

def SoShapeStyleElement_setVertexArrayRendering(*args):
  """SoShapeStyleElement_setVertexArrayRendering(SoState state, SbBool value)"""
  return _coin.SoShapeStyleElement_setVertexArrayRendering(*args)

def SoShapeStyleElement_setTransparentMaterial(*args):
  """SoShapeStyleElement_setTransparentMaterial(SoState state, SbBool value)"""
  return _coin.SoShapeStyleElement_setTransparentMaterial(*args)

def SoShapeStyleElement_setTransparentTexture(*args):
  """SoShapeStyleElement_setTransparentTexture(SoState state, SbBool value)"""
  return _coin.SoShapeStyleElement_setTransparentTexture(*args)

def SoShapeStyleElement_setShadowMapRendering(*args):
  """SoShapeStyleElement_setShadowMapRendering(SoState state, SbBool value)"""
  return _coin.SoShapeStyleElement_setShadowMapRendering(*args)

def SoShapeStyleElement_setShadowsRendering(*args):
  """SoShapeStyleElement_setShadowsRendering(SoState state, SbBool value)"""
  return _coin.SoShapeStyleElement_setShadowsRendering(*args)

class SoViewportRegionElement(SoElement):
    """Proxy of C++ SoViewportRegionElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoViewportRegionElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoViewportRegionElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoViewportRegionElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoViewportRegionElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoViewportRegionElement_init(self, *args)

    def matches(self, *args):
        """matches(self, SoElement element) -> SbBool"""
        return _coin.SoViewportRegionElement_matches(self, *args)

    def copyMatchInfo(self):
        """copyMatchInfo(self) -> SoElement"""
        return _coin.SoViewportRegionElement_copyMatchInfo(self)

    def set(*args):
        """set(SoState state, SbViewportRegion viewportRegion)"""
        return _coin.SoViewportRegionElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> SbViewportRegion"""
        return _coin.SoViewportRegionElement_get(*args)

    get = staticmethod(get)
    def output(self, *args):
        """output(self, FILE file)"""
        return _coin.SoViewportRegionElement_output(self, *args)

SoViewportRegionElement_swigregister = _coin.SoViewportRegionElement_swigregister
SoViewportRegionElement_swigregister(SoViewportRegionElement)

def SoViewportRegionElement_getClassTypeId():
  """SoViewportRegionElement_getClassTypeId() -> SoType"""
  return _coin.SoViewportRegionElement_getClassTypeId()

def SoViewportRegionElement_getClassStackIndex():
  """SoViewportRegionElement_getClassStackIndex() -> int"""
  return _coin.SoViewportRegionElement_getClassStackIndex()

def SoViewportRegionElement_createInstance():
  """SoViewportRegionElement_createInstance() -> void"""
  return _coin.SoViewportRegionElement_createInstance()

def SoViewportRegionElement_initClass():
  """SoViewportRegionElement_initClass()"""
  return _coin.SoViewportRegionElement_initClass()

def SoViewportRegionElement_set(*args):
  """SoViewportRegionElement_set(SoState state, SbViewportRegion viewportRegion)"""
  return _coin.SoViewportRegionElement_set(*args)

def SoViewportRegionElement_get(*args):
  """SoViewportRegionElement_get(SoState state) -> SbViewportRegion"""
  return _coin.SoViewportRegionElement_get(*args)

class SoGLViewportRegionElement(SoViewportRegionElement):
    """Proxy of C++ SoGLViewportRegionElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLViewportRegionElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLViewportRegionElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLViewportRegionElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLViewportRegionElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLViewportRegionElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoGLViewportRegionElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLViewportRegionElement_pop(self, *args)

SoGLViewportRegionElement_swigregister = _coin.SoGLViewportRegionElement_swigregister
SoGLViewportRegionElement_swigregister(SoGLViewportRegionElement)

def SoGLViewportRegionElement_getClassTypeId():
  """SoGLViewportRegionElement_getClassTypeId() -> SoType"""
  return _coin.SoGLViewportRegionElement_getClassTypeId()

def SoGLViewportRegionElement_getClassStackIndex():
  """SoGLViewportRegionElement_getClassStackIndex() -> int"""
  return _coin.SoGLViewportRegionElement_getClassStackIndex()

def SoGLViewportRegionElement_createInstance():
  """SoGLViewportRegionElement_createInstance() -> void"""
  return _coin.SoGLViewportRegionElement_createInstance()

def SoGLViewportRegionElement_initClass():
  """SoGLViewportRegionElement_initClass()"""
  return _coin.SoGLViewportRegionElement_initClass()

class SoWindowElement(SoElement):
    """Proxy of C++ SoWindowElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoWindowElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoWindowElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoWindowElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoWindowElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoWindowElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoWindowElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoWindowElement_pop(self, *args)

    def matches(self, *args):
        """matches(self, SoElement element) -> SbBool"""
        return _coin.SoWindowElement_matches(self, *args)

    def copyMatchInfo(self):
        """copyMatchInfo(self) -> SoElement"""
        return _coin.SoWindowElement_copyMatchInfo(self)

    def set(*args):
        """
        set(SoState state, void window, void context, void display, 
            SoGLRenderAction action)
        """
        return _coin.SoWindowElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """
        get(SoState state, void window, void context, void display, 
            SoGLRenderAction action)
        """
        return _coin.SoWindowElement_get(*args)

    get = staticmethod(get)
SoWindowElement_swigregister = _coin.SoWindowElement_swigregister
SoWindowElement_swigregister(SoWindowElement)

def SoWindowElement_getClassTypeId():
  """SoWindowElement_getClassTypeId() -> SoType"""
  return _coin.SoWindowElement_getClassTypeId()

def SoWindowElement_getClassStackIndex():
  """SoWindowElement_getClassStackIndex() -> int"""
  return _coin.SoWindowElement_getClassStackIndex()

def SoWindowElement_createInstance():
  """SoWindowElement_createInstance() -> void"""
  return _coin.SoWindowElement_createInstance()

def SoWindowElement_initClass():
  """SoWindowElement_initClass()"""
  return _coin.SoWindowElement_initClass()

def SoWindowElement_set(*args):
  """
    SoWindowElement_set(SoState state, void window, void context, void display, 
        SoGLRenderAction action)
    """
  return _coin.SoWindowElement_set(*args)

def SoWindowElement_get(*args):
  """
    SoWindowElement_get(SoState state, void window, void context, void display, 
        SoGLRenderAction action)
    """
  return _coin.SoWindowElement_get(*args)

class SoGLCacheContextElement(SoElement):
    """Proxy of C++ SoGLCacheContextElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLCacheContextElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLCacheContextElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLCacheContextElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLCacheContextElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLCacheContextElement_init(self, *args)

    def matches(self, *args):
        """matches(self, SoElement elt) -> SbBool"""
        return _coin.SoGLCacheContextElement_matches(self, *args)

    def copyMatchInfo(self):
        """copyMatchInfo(self) -> SoElement"""
        return _coin.SoGLCacheContextElement_copyMatchInfo(self)

    def set(*args):
        """
        set(SoState state, int context, SbBool twopasstransparency, 
            SbBool remoterendering)
        """
        return _coin.SoGLCacheContextElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> int"""
        return _coin.SoGLCacheContextElement_get(*args)

    get = staticmethod(get)
    def getExtID(*args):
        """getExtID(char str) -> int"""
        return _coin.SoGLCacheContextElement_getExtID(*args)

    getExtID = staticmethod(getExtID)
    def getOpenGLVersion(*args):
        """getOpenGLVersion(SoState state, int major, int minor)"""
        return _coin.SoGLCacheContextElement_getOpenGLVersion(*args)

    getOpenGLVersion = staticmethod(getOpenGLVersion)
    def extSupported(*args):
        """extSupported(SoState state, int extid) -> SbBool"""
        return _coin.SoGLCacheContextElement_extSupported(*args)

    extSupported = staticmethod(extSupported)
    def areMipMapsFast(*args):
        """areMipMapsFast(SoState state) -> SbBool"""
        return _coin.SoGLCacheContextElement_areMipMapsFast(*args)

    areMipMapsFast = staticmethod(areMipMapsFast)
    DO_AUTO_CACHE = _coin.SoGLCacheContextElement_DO_AUTO_CACHE
    DONT_AUTO_CACHE = _coin.SoGLCacheContextElement_DONT_AUTO_CACHE
    def shouldAutoCache(*args):
        """shouldAutoCache(SoState state, int bits)"""
        return _coin.SoGLCacheContextElement_shouldAutoCache(*args)

    shouldAutoCache = staticmethod(shouldAutoCache)
    def setAutoCacheBits(*args):
        """setAutoCacheBits(SoState state, int bits)"""
        return _coin.SoGLCacheContextElement_setAutoCacheBits(*args)

    setAutoCacheBits = staticmethod(setAutoCacheBits)
    def resetAutoCacheBits(*args):
        """resetAutoCacheBits(SoState state) -> int"""
        return _coin.SoGLCacheContextElement_resetAutoCacheBits(*args)

    resetAutoCacheBits = staticmethod(resetAutoCacheBits)
    def getIsRemoteRendering(*args):
        """getIsRemoteRendering(SoState state) -> SbBool"""
        return _coin.SoGLCacheContextElement_getIsRemoteRendering(*args)

    getIsRemoteRendering = staticmethod(getIsRemoteRendering)
    def getUniqueCacheContext():
        """getUniqueCacheContext() -> uint32_t"""
        return _coin.SoGLCacheContextElement_getUniqueCacheContext()

    getUniqueCacheContext = staticmethod(getUniqueCacheContext)
    def scheduleDeleteCallback(*args):
        """scheduleDeleteCallback(uint32_t contextid, SoScheduleDeleteCB cb, void closure)"""
        return _coin.SoGLCacheContextElement_scheduleDeleteCallback(*args)

    scheduleDeleteCallback = staticmethod(scheduleDeleteCallback)
    def incNumShapes(*args):
        """incNumShapes(SoState state)"""
        return _coin.SoGLCacheContextElement_incNumShapes(*args)

    incNumShapes = staticmethod(incNumShapes)
    def getNumShapes(*args):
        """getNumShapes(SoState state) -> int"""
        return _coin.SoGLCacheContextElement_getNumShapes(*args)

    getNumShapes = staticmethod(getNumShapes)
    def incNumSeparators(*args):
        """incNumSeparators(SoState state)"""
        return _coin.SoGLCacheContextElement_incNumSeparators(*args)

    incNumSeparators = staticmethod(incNumSeparators)
    def getNumSeparators(*args):
        """getNumSeparators(SoState state) -> int"""
        return _coin.SoGLCacheContextElement_getNumSeparators(*args)

    getNumSeparators = staticmethod(getNumSeparators)
SoGLCacheContextElement_swigregister = _coin.SoGLCacheContextElement_swigregister
SoGLCacheContextElement_swigregister(SoGLCacheContextElement)

def SoGLCacheContextElement_getClassTypeId():
  """SoGLCacheContextElement_getClassTypeId() -> SoType"""
  return _coin.SoGLCacheContextElement_getClassTypeId()

def SoGLCacheContextElement_getClassStackIndex():
  """SoGLCacheContextElement_getClassStackIndex() -> int"""
  return _coin.SoGLCacheContextElement_getClassStackIndex()

def SoGLCacheContextElement_createInstance():
  """SoGLCacheContextElement_createInstance() -> void"""
  return _coin.SoGLCacheContextElement_createInstance()

def SoGLCacheContextElement_initClass():
  """SoGLCacheContextElement_initClass()"""
  return _coin.SoGLCacheContextElement_initClass()

def SoGLCacheContextElement_set(*args):
  """
    SoGLCacheContextElement_set(SoState state, int context, SbBool twopasstransparency, 
        SbBool remoterendering)
    """
  return _coin.SoGLCacheContextElement_set(*args)

def SoGLCacheContextElement_get(*args):
  """SoGLCacheContextElement_get(SoState state) -> int"""
  return _coin.SoGLCacheContextElement_get(*args)

def SoGLCacheContextElement_getExtID(*args):
  """SoGLCacheContextElement_getExtID(char str) -> int"""
  return _coin.SoGLCacheContextElement_getExtID(*args)

def SoGLCacheContextElement_getOpenGLVersion(*args):
  """SoGLCacheContextElement_getOpenGLVersion(SoState state, int major, int minor)"""
  return _coin.SoGLCacheContextElement_getOpenGLVersion(*args)

def SoGLCacheContextElement_extSupported(*args):
  """SoGLCacheContextElement_extSupported(SoState state, int extid) -> SbBool"""
  return _coin.SoGLCacheContextElement_extSupported(*args)

def SoGLCacheContextElement_areMipMapsFast(*args):
  """SoGLCacheContextElement_areMipMapsFast(SoState state) -> SbBool"""
  return _coin.SoGLCacheContextElement_areMipMapsFast(*args)

def SoGLCacheContextElement_shouldAutoCache(*args):
  """SoGLCacheContextElement_shouldAutoCache(SoState state, int bits)"""
  return _coin.SoGLCacheContextElement_shouldAutoCache(*args)

def SoGLCacheContextElement_setAutoCacheBits(*args):
  """SoGLCacheContextElement_setAutoCacheBits(SoState state, int bits)"""
  return _coin.SoGLCacheContextElement_setAutoCacheBits(*args)

def SoGLCacheContextElement_resetAutoCacheBits(*args):
  """SoGLCacheContextElement_resetAutoCacheBits(SoState state) -> int"""
  return _coin.SoGLCacheContextElement_resetAutoCacheBits(*args)

def SoGLCacheContextElement_getIsRemoteRendering(*args):
  """SoGLCacheContextElement_getIsRemoteRendering(SoState state) -> SbBool"""
  return _coin.SoGLCacheContextElement_getIsRemoteRendering(*args)

def SoGLCacheContextElement_getUniqueCacheContext():
  """SoGLCacheContextElement_getUniqueCacheContext() -> uint32_t"""
  return _coin.SoGLCacheContextElement_getUniqueCacheContext()

def SoGLCacheContextElement_scheduleDeleteCallback(*args):
  """SoGLCacheContextElement_scheduleDeleteCallback(uint32_t contextid, SoScheduleDeleteCB cb, void closure)"""
  return _coin.SoGLCacheContextElement_scheduleDeleteCallback(*args)

def SoGLCacheContextElement_incNumShapes(*args):
  """SoGLCacheContextElement_incNumShapes(SoState state)"""
  return _coin.SoGLCacheContextElement_incNumShapes(*args)

def SoGLCacheContextElement_getNumShapes(*args):
  """SoGLCacheContextElement_getNumShapes(SoState state) -> int"""
  return _coin.SoGLCacheContextElement_getNumShapes(*args)

def SoGLCacheContextElement_incNumSeparators(*args):
  """SoGLCacheContextElement_incNumSeparators(SoState state)"""
  return _coin.SoGLCacheContextElement_incNumSeparators(*args)

def SoGLCacheContextElement_getNumSeparators(*args):
  """SoGLCacheContextElement_getNumSeparators(SoState state) -> int"""
  return _coin.SoGLCacheContextElement_getNumSeparators(*args)

class SoGLDisplayList(object):
    """Proxy of C++ SoGLDisplayList class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    DISPLAY_LIST = _coin.SoGLDisplayList_DISPLAY_LIST
    TEXTURE_OBJECT = _coin.SoGLDisplayList_TEXTURE_OBJECT
    def __init__(self, *args): 
        """
        __init__(self, SoState state, Type type, int allocnum = 1, SbBool mipmaptexobj = 0) -> SoGLDisplayList
        __init__(self, SoState state, Type type, int allocnum = 1) -> SoGLDisplayList
        __init__(self, SoState state, Type type) -> SoGLDisplayList
        """
        this = _coin.new_SoGLDisplayList(*args)
        try: self.this.append(this)
        except: self.this = this
    def ref(self):
        """ref(self)"""
        return _coin.SoGLDisplayList_ref(self)

    def unref(self, state = None):
        """
        unref(self, SoState state = None)
        unref(self)
        """
        return _coin.SoGLDisplayList_unref(self, state)

    def open(self, *args):
        """
        open(self, SoState state, int index = 0)
        open(self, SoState state)
        """
        return _coin.SoGLDisplayList_open(self, *args)

    def close(self, *args):
        """close(self, SoState state)"""
        return _coin.SoGLDisplayList_close(self, *args)

    def call(self, *args):
        """
        call(self, SoState state, int index = 0)
        call(self, SoState state)
        """
        return _coin.SoGLDisplayList_call(self, *args)

    def addDependency(self, *args):
        """addDependency(self, SoState state)"""
        return _coin.SoGLDisplayList_addDependency(self, *args)

    def isMipMapTextureObject(self):
        """isMipMapTextureObject(self) -> SbBool"""
        return _coin.SoGLDisplayList_isMipMapTextureObject(self)

    def getType(self):
        """getType(self) -> Type"""
        return _coin.SoGLDisplayList_getType(self)

    def getNumAllocated(self):
        """getNumAllocated(self) -> int"""
        return _coin.SoGLDisplayList_getNumAllocated(self)

    def getFirstIndex(self):
        """getFirstIndex(self) -> unsigned int"""
        return _coin.SoGLDisplayList_getFirstIndex(self)

    def getContext(self):
        """getContext(self) -> int"""
        return _coin.SoGLDisplayList_getContext(self)

    def setTextureTarget(self, *args):
        """setTextureTarget(self, int target)"""
        return _coin.SoGLDisplayList_setTextureTarget(self, *args)

    def getTextureTarget(self):
        """getTextureTarget(self) -> int"""
        return _coin.SoGLDisplayList_getTextureTarget(self)

SoGLDisplayList_swigregister = _coin.SoGLDisplayList_swigregister
SoGLDisplayList_swigregister(SoGLDisplayList)

class SoGLColorIndexElement(SoReplacedElement):
    """Proxy of C++ SoGLColorIndexElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLColorIndexElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLColorIndexElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLColorIndexElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLColorIndexElement_initClass()

    initClass = staticmethod(initClass)
    def isColorIndexMode(*args):
        """isColorIndexMode(SoState state) -> SbBool"""
        return _coin.SoGLColorIndexElement_isColorIndexMode(*args)

    isColorIndexMode = staticmethod(isColorIndexMode)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLColorIndexElement_init(self, *args)

    def set(*args):
        """set(SoState state, SoNode node, int32_t numindices, int32_t indices)"""
        return _coin.SoGLColorIndexElement_set(*args)

    set = staticmethod(set)
    def getInstance(*args):
        """getInstance(SoState state) -> SoGLColorIndexElement"""
        return _coin.SoGLColorIndexElement_getInstance(*args)

    getInstance = staticmethod(getInstance)
    def getNum(self):
        """getNum(self) -> int32_t"""
        return _coin.SoGLColorIndexElement_getNum(self)

    def get(self, *args):
        """get(self, int index) -> int32_t"""
        return _coin.SoGLColorIndexElement_get(self, *args)

    def getDefault():
        """getDefault() -> int32_t"""
        return _coin.SoGLColorIndexElement_getDefault()

    getDefault = staticmethod(getDefault)
SoGLColorIndexElement_swigregister = _coin.SoGLColorIndexElement_swigregister
SoGLColorIndexElement_swigregister(SoGLColorIndexElement)

def SoGLColorIndexElement_getClassTypeId():
  """SoGLColorIndexElement_getClassTypeId() -> SoType"""
  return _coin.SoGLColorIndexElement_getClassTypeId()

def SoGLColorIndexElement_getClassStackIndex():
  """SoGLColorIndexElement_getClassStackIndex() -> int"""
  return _coin.SoGLColorIndexElement_getClassStackIndex()

def SoGLColorIndexElement_createInstance():
  """SoGLColorIndexElement_createInstance() -> void"""
  return _coin.SoGLColorIndexElement_createInstance()

def SoGLColorIndexElement_initClass():
  """SoGLColorIndexElement_initClass()"""
  return _coin.SoGLColorIndexElement_initClass()

def SoGLColorIndexElement_isColorIndexMode(*args):
  """SoGLColorIndexElement_isColorIndexMode(SoState state) -> SbBool"""
  return _coin.SoGLColorIndexElement_isColorIndexMode(*args)

def SoGLColorIndexElement_set(*args):
  """SoGLColorIndexElement_set(SoState state, SoNode node, int32_t numindices, int32_t indices)"""
  return _coin.SoGLColorIndexElement_set(*args)

def SoGLColorIndexElement_getInstance(*args):
  """SoGLColorIndexElement_getInstance(SoState state) -> SoGLColorIndexElement"""
  return _coin.SoGLColorIndexElement_getInstance(*args)

def SoGLColorIndexElement_getDefault():
  """SoGLColorIndexElement_getDefault() -> int32_t"""
  return _coin.SoGLColorIndexElement_getDefault()

class SoListenerPositionElement(SoReplacedElement):
    """Proxy of C++ SoListenerPositionElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoListenerPositionElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoListenerPositionElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoListenerPositionElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoListenerPositionElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoListenerPositionElement_init(self, *args)

    def set(*args):
        """set(SoState state, SoNode node, SbVec3f position, SbBool setbylistener)"""
        return _coin.SoListenerPositionElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> SbVec3f"""
        return _coin.SoListenerPositionElement_get(*args)

    get = staticmethod(get)
    def isSetByListener(*args):
        """isSetByListener(SoState state) -> SbBool"""
        return _coin.SoListenerPositionElement_isSetByListener(*args)

    isSetByListener = staticmethod(isSetByListener)
    def output(self, *args):
        """output(self, FILE file)"""
        return _coin.SoListenerPositionElement_output(self, *args)

SoListenerPositionElement_swigregister = _coin.SoListenerPositionElement_swigregister
SoListenerPositionElement_swigregister(SoListenerPositionElement)

def SoListenerPositionElement_getClassTypeId():
  """SoListenerPositionElement_getClassTypeId() -> SoType"""
  return _coin.SoListenerPositionElement_getClassTypeId()

def SoListenerPositionElement_getClassStackIndex():
  """SoListenerPositionElement_getClassStackIndex() -> int"""
  return _coin.SoListenerPositionElement_getClassStackIndex()

def SoListenerPositionElement_createInstance():
  """SoListenerPositionElement_createInstance() -> void"""
  return _coin.SoListenerPositionElement_createInstance()

def SoListenerPositionElement_initClass():
  """SoListenerPositionElement_initClass()"""
  return _coin.SoListenerPositionElement_initClass()

def SoListenerPositionElement_set(*args):
  """SoListenerPositionElement_set(SoState state, SoNode node, SbVec3f position, SbBool setbylistener)"""
  return _coin.SoListenerPositionElement_set(*args)

def SoListenerPositionElement_get(*args):
  """SoListenerPositionElement_get(SoState state) -> SbVec3f"""
  return _coin.SoListenerPositionElement_get(*args)

def SoListenerPositionElement_isSetByListener(*args):
  """SoListenerPositionElement_isSetByListener(SoState state) -> SbBool"""
  return _coin.SoListenerPositionElement_isSetByListener(*args)

class SoListenerOrientationElement(SoReplacedElement):
    """Proxy of C++ SoListenerOrientationElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoListenerOrientationElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoListenerOrientationElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoListenerOrientationElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoListenerOrientationElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoListenerOrientationElement_init(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, SbRotation orientation, 
            SbBool setbylistener)
        """
        return _coin.SoListenerOrientationElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> SbRotation"""
        return _coin.SoListenerOrientationElement_get(*args)

    get = staticmethod(get)
    def isSetByListener(*args):
        """isSetByListener(SoState state) -> SbBool"""
        return _coin.SoListenerOrientationElement_isSetByListener(*args)

    isSetByListener = staticmethod(isSetByListener)
    def output(self, *args):
        """output(self, FILE file)"""
        return _coin.SoListenerOrientationElement_output(self, *args)

SoListenerOrientationElement_swigregister = _coin.SoListenerOrientationElement_swigregister
SoListenerOrientationElement_swigregister(SoListenerOrientationElement)

def SoListenerOrientationElement_getClassTypeId():
  """SoListenerOrientationElement_getClassTypeId() -> SoType"""
  return _coin.SoListenerOrientationElement_getClassTypeId()

def SoListenerOrientationElement_getClassStackIndex():
  """SoListenerOrientationElement_getClassStackIndex() -> int"""
  return _coin.SoListenerOrientationElement_getClassStackIndex()

def SoListenerOrientationElement_createInstance():
  """SoListenerOrientationElement_createInstance() -> void"""
  return _coin.SoListenerOrientationElement_createInstance()

def SoListenerOrientationElement_initClass():
  """SoListenerOrientationElement_initClass()"""
  return _coin.SoListenerOrientationElement_initClass()

def SoListenerOrientationElement_set(*args):
  """
    SoListenerOrientationElement_set(SoState state, SoNode node, SbRotation orientation, 
        SbBool setbylistener)
    """
  return _coin.SoListenerOrientationElement_set(*args)

def SoListenerOrientationElement_get(*args):
  """SoListenerOrientationElement_get(SoState state) -> SbRotation"""
  return _coin.SoListenerOrientationElement_get(*args)

def SoListenerOrientationElement_isSetByListener(*args):
  """SoListenerOrientationElement_isSetByListener(SoState state) -> SbBool"""
  return _coin.SoListenerOrientationElement_isSetByListener(*args)

class SoListenerDopplerElement(SoReplacedElement):
    """Proxy of C++ SoListenerDopplerElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoListenerDopplerElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoListenerDopplerElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoListenerDopplerElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoListenerDopplerElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoListenerDopplerElement_init(self, *args)

    def setDopplerVelocity(*args):
        """setDopplerVelocity(SoState state, SoNode node, SbVec3f velocity)"""
        return _coin.SoListenerDopplerElement_setDopplerVelocity(*args)

    setDopplerVelocity = staticmethod(setDopplerVelocity)
    def setDopplerFactor(*args):
        """setDopplerFactor(SoState state, SoNode node, float factor)"""
        return _coin.SoListenerDopplerElement_setDopplerFactor(*args)

    setDopplerFactor = staticmethod(setDopplerFactor)
    def getDopplerVelocity(*args):
        """getDopplerVelocity(SoState state) -> SbVec3f"""
        return _coin.SoListenerDopplerElement_getDopplerVelocity(*args)

    getDopplerVelocity = staticmethod(getDopplerVelocity)
    def getDopplerFactor(*args):
        """getDopplerFactor(SoState state) -> float"""
        return _coin.SoListenerDopplerElement_getDopplerFactor(*args)

    getDopplerFactor = staticmethod(getDopplerFactor)
    def output(self, *args):
        """output(self, FILE file)"""
        return _coin.SoListenerDopplerElement_output(self, *args)

SoListenerDopplerElement_swigregister = _coin.SoListenerDopplerElement_swigregister
SoListenerDopplerElement_swigregister(SoListenerDopplerElement)

def SoListenerDopplerElement_getClassTypeId():
  """SoListenerDopplerElement_getClassTypeId() -> SoType"""
  return _coin.SoListenerDopplerElement_getClassTypeId()

def SoListenerDopplerElement_getClassStackIndex():
  """SoListenerDopplerElement_getClassStackIndex() -> int"""
  return _coin.SoListenerDopplerElement_getClassStackIndex()

def SoListenerDopplerElement_createInstance():
  """SoListenerDopplerElement_createInstance() -> void"""
  return _coin.SoListenerDopplerElement_createInstance()

def SoListenerDopplerElement_initClass():
  """SoListenerDopplerElement_initClass()"""
  return _coin.SoListenerDopplerElement_initClass()

def SoListenerDopplerElement_setDopplerVelocity(*args):
  """SoListenerDopplerElement_setDopplerVelocity(SoState state, SoNode node, SbVec3f velocity)"""
  return _coin.SoListenerDopplerElement_setDopplerVelocity(*args)

def SoListenerDopplerElement_setDopplerFactor(*args):
  """SoListenerDopplerElement_setDopplerFactor(SoState state, SoNode node, float factor)"""
  return _coin.SoListenerDopplerElement_setDopplerFactor(*args)

def SoListenerDopplerElement_getDopplerVelocity(*args):
  """SoListenerDopplerElement_getDopplerVelocity(SoState state) -> SbVec3f"""
  return _coin.SoListenerDopplerElement_getDopplerVelocity(*args)

def SoListenerDopplerElement_getDopplerFactor(*args):
  """SoListenerDopplerElement_getDopplerFactor(SoState state) -> float"""
  return _coin.SoListenerDopplerElement_getDopplerFactor(*args)

class SoListenerGainElement(SoFloatElement):
    """Proxy of C++ SoListenerGainElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoListenerGainElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoListenerGainElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoListenerGainElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoListenerGainElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoListenerGainElement_init(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, float gain)
        set(SoState state, float gain)
        """
        return _coin.SoListenerGainElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> float"""
        return _coin.SoListenerGainElement_get(*args)

    get = staticmethod(get)
SoListenerGainElement_swigregister = _coin.SoListenerGainElement_swigregister
SoListenerGainElement_swigregister(SoListenerGainElement)

def SoListenerGainElement_getClassTypeId():
  """SoListenerGainElement_getClassTypeId() -> SoType"""
  return _coin.SoListenerGainElement_getClassTypeId()

def SoListenerGainElement_getClassStackIndex():
  """SoListenerGainElement_getClassStackIndex() -> int"""
  return _coin.SoListenerGainElement_getClassStackIndex()

def SoListenerGainElement_createInstance():
  """SoListenerGainElement_createInstance() -> void"""
  return _coin.SoListenerGainElement_createInstance()

def SoListenerGainElement_initClass():
  """SoListenerGainElement_initClass()"""
  return _coin.SoListenerGainElement_initClass()

def SoListenerGainElement_set(*args):
  """
    set(SoState state, SoNode node, float gain)
    SoListenerGainElement_set(SoState state, float gain)
    """
  return _coin.SoListenerGainElement_set(*args)

def SoListenerGainElement_get(*args):
  """SoListenerGainElement_get(SoState state) -> float"""
  return _coin.SoListenerGainElement_get(*args)

class SoSoundElement(SoReplacedElement):
    """Proxy of C++ SoSoundElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSoundElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoSoundElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSoundElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoSoundElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoSoundElement_init(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, SbBool scenegraphhassoundnode, 
            SbBool soundnodeisplaying, SbBool ispartofactivescenegraph)
        """
        return _coin.SoSoundElement_set(*args)

    set = staticmethod(set)
    def setSceneGraphHasSoundNode(*args):
        """setSceneGraphHasSoundNode(SoState state, SoNode node, SbBool flag) -> SbBool"""
        return _coin.SoSoundElement_setSceneGraphHasSoundNode(*args)

    setSceneGraphHasSoundNode = staticmethod(setSceneGraphHasSoundNode)
    def sceneGraphHasSoundNode(*args):
        """sceneGraphHasSoundNode(SoState state) -> SbBool"""
        return _coin.SoSoundElement_sceneGraphHasSoundNode(*args)

    sceneGraphHasSoundNode = staticmethod(sceneGraphHasSoundNode)
    def setSoundNodeIsPlaying(*args):
        """setSoundNodeIsPlaying(SoState state, SoNode node, SbBool flag) -> SbBool"""
        return _coin.SoSoundElement_setSoundNodeIsPlaying(*args)

    setSoundNodeIsPlaying = staticmethod(setSoundNodeIsPlaying)
    def soundNodeIsPlaying(*args):
        """soundNodeIsPlaying(SoState state) -> SbBool"""
        return _coin.SoSoundElement_soundNodeIsPlaying(*args)

    soundNodeIsPlaying = staticmethod(soundNodeIsPlaying)
    def setIsPartOfActiveSceneGraph(*args):
        """setIsPartOfActiveSceneGraph(SoState state, SoNode node, SbBool flag) -> SbBool"""
        return _coin.SoSoundElement_setIsPartOfActiveSceneGraph(*args)

    setIsPartOfActiveSceneGraph = staticmethod(setIsPartOfActiveSceneGraph)
    def isPartOfActiveSceneGraph(*args):
        """isPartOfActiveSceneGraph(SoState state) -> SbBool"""
        return _coin.SoSoundElement_isPartOfActiveSceneGraph(*args)

    isPartOfActiveSceneGraph = staticmethod(isPartOfActiveSceneGraph)
    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoSoundElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoSoundElement_pop(self, *args)

    def output(self, *args):
        """output(self, FILE file)"""
        return _coin.SoSoundElement_output(self, *args)

SoSoundElement_swigregister = _coin.SoSoundElement_swigregister
SoSoundElement_swigregister(SoSoundElement)

def SoSoundElement_getClassTypeId():
  """SoSoundElement_getClassTypeId() -> SoType"""
  return _coin.SoSoundElement_getClassTypeId()

def SoSoundElement_getClassStackIndex():
  """SoSoundElement_getClassStackIndex() -> int"""
  return _coin.SoSoundElement_getClassStackIndex()

def SoSoundElement_createInstance():
  """SoSoundElement_createInstance() -> void"""
  return _coin.SoSoundElement_createInstance()

def SoSoundElement_initClass():
  """SoSoundElement_initClass()"""
  return _coin.SoSoundElement_initClass()

def SoSoundElement_set(*args):
  """
    SoSoundElement_set(SoState state, SoNode node, SbBool scenegraphhassoundnode, 
        SbBool soundnodeisplaying, SbBool ispartofactivescenegraph)
    """
  return _coin.SoSoundElement_set(*args)

def SoSoundElement_setSceneGraphHasSoundNode(*args):
  """SoSoundElement_setSceneGraphHasSoundNode(SoState state, SoNode node, SbBool flag) -> SbBool"""
  return _coin.SoSoundElement_setSceneGraphHasSoundNode(*args)

def SoSoundElement_sceneGraphHasSoundNode(*args):
  """SoSoundElement_sceneGraphHasSoundNode(SoState state) -> SbBool"""
  return _coin.SoSoundElement_sceneGraphHasSoundNode(*args)

def SoSoundElement_setSoundNodeIsPlaying(*args):
  """SoSoundElement_setSoundNodeIsPlaying(SoState state, SoNode node, SbBool flag) -> SbBool"""
  return _coin.SoSoundElement_setSoundNodeIsPlaying(*args)

def SoSoundElement_soundNodeIsPlaying(*args):
  """SoSoundElement_soundNodeIsPlaying(SoState state) -> SbBool"""
  return _coin.SoSoundElement_soundNodeIsPlaying(*args)

def SoSoundElement_setIsPartOfActiveSceneGraph(*args):
  """SoSoundElement_setIsPartOfActiveSceneGraph(SoState state, SoNode node, SbBool flag) -> SbBool"""
  return _coin.SoSoundElement_setIsPartOfActiveSceneGraph(*args)

def SoSoundElement_isPartOfActiveSceneGraph(*args):
  """SoSoundElement_isPartOfActiveSceneGraph(SoState state) -> SbBool"""
  return _coin.SoSoundElement_isPartOfActiveSceneGraph(*args)

class SoGLVBOElement(SoElement):
    """Proxy of C++ SoGLVBOElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLVBOElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLVBOElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLVBOElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLVBOElement_initClass()

    initClass = staticmethod(initClass)
    def shouldCreateVBO(*args):
        """shouldCreateVBO(SoState state, int numdata) -> SbBool"""
        return _coin.SoGLVBOElement_shouldCreateVBO(*args)

    shouldCreateVBO = staticmethod(shouldCreateVBO)
    def setVertexVBO(*args):
        """setVertexVBO(SoState state, SoVBO vbo)"""
        return _coin.SoGLVBOElement_setVertexVBO(*args)

    setVertexVBO = staticmethod(setVertexVBO)
    def setNormalVBO(*args):
        """setNormalVBO(SoState state, SoVBO vbo)"""
        return _coin.SoGLVBOElement_setNormalVBO(*args)

    setNormalVBO = staticmethod(setNormalVBO)
    def setColorVBO(*args):
        """setColorVBO(SoState state, SoVBO vbo)"""
        return _coin.SoGLVBOElement_setColorVBO(*args)

    setColorVBO = staticmethod(setColorVBO)
    def setTexCoordVBO(*args):
        """setTexCoordVBO(SoState state, int unit, SoVBO vbo)"""
        return _coin.SoGLVBOElement_setTexCoordVBO(*args)

    setTexCoordVBO = staticmethod(setTexCoordVBO)
    def getInstance(*args):
        """getInstance(SoState state) -> SoGLVBOElement"""
        return _coin.SoGLVBOElement_getInstance(*args)

    getInstance = staticmethod(getInstance)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLVBOElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoGLVBOElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevtopelement)"""
        return _coin.SoGLVBOElement_pop(self, *args)

    def matches(self, *args):
        """matches(self, SoElement elt) -> SbBool"""
        return _coin.SoGLVBOElement_matches(self, *args)

    def copyMatchInfo(self):
        """copyMatchInfo(self) -> SoElement"""
        return _coin.SoGLVBOElement_copyMatchInfo(self)

    def getVertexVBO(self):
        """getVertexVBO(self) -> SoVBO"""
        return _coin.SoGLVBOElement_getVertexVBO(self)

    def getNormalVBO(self):
        """getNormalVBO(self) -> SoVBO"""
        return _coin.SoGLVBOElement_getNormalVBO(self)

    def getColorVBO(self):
        """getColorVBO(self) -> SoVBO"""
        return _coin.SoGLVBOElement_getColorVBO(self)

    def getNumTexCoordVBO(self):
        """getNumTexCoordVBO(self) -> int"""
        return _coin.SoGLVBOElement_getNumTexCoordVBO(self)

    def getTexCoordVBO(self, *args):
        """getTexCoordVBO(self, int idx) -> SoVBO"""
        return _coin.SoGLVBOElement_getTexCoordVBO(self, *args)

SoGLVBOElement_swigregister = _coin.SoGLVBOElement_swigregister
SoGLVBOElement_swigregister(SoGLVBOElement)

def SoGLVBOElement_getClassTypeId():
  """SoGLVBOElement_getClassTypeId() -> SoType"""
  return _coin.SoGLVBOElement_getClassTypeId()

def SoGLVBOElement_getClassStackIndex():
  """SoGLVBOElement_getClassStackIndex() -> int"""
  return _coin.SoGLVBOElement_getClassStackIndex()

def SoGLVBOElement_createInstance():
  """SoGLVBOElement_createInstance() -> void"""
  return _coin.SoGLVBOElement_createInstance()

def SoGLVBOElement_initClass():
  """SoGLVBOElement_initClass()"""
  return _coin.SoGLVBOElement_initClass()

def SoGLVBOElement_shouldCreateVBO(*args):
  """SoGLVBOElement_shouldCreateVBO(SoState state, int numdata) -> SbBool"""
  return _coin.SoGLVBOElement_shouldCreateVBO(*args)

def SoGLVBOElement_setVertexVBO(*args):
  """SoGLVBOElement_setVertexVBO(SoState state, SoVBO vbo)"""
  return _coin.SoGLVBOElement_setVertexVBO(*args)

def SoGLVBOElement_setNormalVBO(*args):
  """SoGLVBOElement_setNormalVBO(SoState state, SoVBO vbo)"""
  return _coin.SoGLVBOElement_setNormalVBO(*args)

def SoGLVBOElement_setColorVBO(*args):
  """SoGLVBOElement_setColorVBO(SoState state, SoVBO vbo)"""
  return _coin.SoGLVBOElement_setColorVBO(*args)

def SoGLVBOElement_setTexCoordVBO(*args):
  """SoGLVBOElement_setTexCoordVBO(SoState state, int unit, SoVBO vbo)"""
  return _coin.SoGLVBOElement_setTexCoordVBO(*args)

def SoGLVBOElement_getInstance(*args):
  """SoGLVBOElement_getInstance(SoState state) -> SoGLVBOElement"""
  return _coin.SoGLVBOElement_getInstance(*args)

class SoDepthBufferElement(SoElement):
    """Proxy of C++ SoDepthBufferElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoDepthBufferElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoDepthBufferElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoDepthBufferElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoDepthBufferElement_initClass()

    initClass = staticmethod(initClass)
    NEVER = _coin.SoDepthBufferElement_NEVER
    ALWAYS = _coin.SoDepthBufferElement_ALWAYS
    LESS = _coin.SoDepthBufferElement_LESS
    LEQUAL = _coin.SoDepthBufferElement_LEQUAL
    EQUAL = _coin.SoDepthBufferElement_EQUAL
    GEQUAL = _coin.SoDepthBufferElement_GEQUAL
    GREATER = _coin.SoDepthBufferElement_GREATER
    NOTEQUAL = _coin.SoDepthBufferElement_NOTEQUAL
    def set(*args):
        """
        set(SoState state, SbBool test, SbBool write, DepthWriteFunction function, 
            SbVec2f range)
        """
        return _coin.SoDepthBufferElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """
        get(SoState state, SbBool test_out, SbBool write_out, DepthWriteFunction function_out, 
            SbVec2f range_out)
        """
        return _coin.SoDepthBufferElement_get(*args)

    get = staticmethod(get)
    def getTestEnable(*args):
        """getTestEnable(SoState state) -> SbBool"""
        return _coin.SoDepthBufferElement_getTestEnable(*args)

    getTestEnable = staticmethod(getTestEnable)
    def getWriteEnable(*args):
        """getWriteEnable(SoState state) -> SbBool"""
        return _coin.SoDepthBufferElement_getWriteEnable(*args)

    getWriteEnable = staticmethod(getWriteEnable)
    def getFunction(*args):
        """getFunction(SoState state) -> DepthWriteFunction"""
        return _coin.SoDepthBufferElement_getFunction(*args)

    getFunction = staticmethod(getFunction)
    def getRange(*args):
        """getRange(SoState state) -> SbVec2f"""
        return _coin.SoDepthBufferElement_getRange(*args)

    getRange = staticmethod(getRange)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoDepthBufferElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoDepthBufferElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoDepthBufferElement_pop(self, *args)

    def matches(self, *args):
        """matches(self, SoElement element) -> SbBool"""
        return _coin.SoDepthBufferElement_matches(self, *args)

    def copyMatchInfo(self):
        """copyMatchInfo(self) -> SoElement"""
        return _coin.SoDepthBufferElement_copyMatchInfo(self)

SoDepthBufferElement_swigregister = _coin.SoDepthBufferElement_swigregister
SoDepthBufferElement_swigregister(SoDepthBufferElement)

def SoDepthBufferElement_getClassTypeId():
  """SoDepthBufferElement_getClassTypeId() -> SoType"""
  return _coin.SoDepthBufferElement_getClassTypeId()

def SoDepthBufferElement_getClassStackIndex():
  """SoDepthBufferElement_getClassStackIndex() -> int"""
  return _coin.SoDepthBufferElement_getClassStackIndex()

def SoDepthBufferElement_createInstance():
  """SoDepthBufferElement_createInstance() -> void"""
  return _coin.SoDepthBufferElement_createInstance()

def SoDepthBufferElement_initClass():
  """SoDepthBufferElement_initClass()"""
  return _coin.SoDepthBufferElement_initClass()

def SoDepthBufferElement_set(*args):
  """
    SoDepthBufferElement_set(SoState state, SbBool test, SbBool write, DepthWriteFunction function, 
        SbVec2f range)
    """
  return _coin.SoDepthBufferElement_set(*args)

def SoDepthBufferElement_get(*args):
  """
    SoDepthBufferElement_get(SoState state, SbBool test_out, SbBool write_out, DepthWriteFunction function_out, 
        SbVec2f range_out)
    """
  return _coin.SoDepthBufferElement_get(*args)

def SoDepthBufferElement_getTestEnable(*args):
  """SoDepthBufferElement_getTestEnable(SoState state) -> SbBool"""
  return _coin.SoDepthBufferElement_getTestEnable(*args)

def SoDepthBufferElement_getWriteEnable(*args):
  """SoDepthBufferElement_getWriteEnable(SoState state) -> SbBool"""
  return _coin.SoDepthBufferElement_getWriteEnable(*args)

def SoDepthBufferElement_getFunction(*args):
  """SoDepthBufferElement_getFunction(SoState state) -> DepthWriteFunction"""
  return _coin.SoDepthBufferElement_getFunction(*args)

def SoDepthBufferElement_getRange(*args):
  """SoDepthBufferElement_getRange(SoState state) -> SbVec2f"""
  return _coin.SoDepthBufferElement_getRange(*args)

class SoGLDepthBufferElement(SoDepthBufferElement):
    """Proxy of C++ SoGLDepthBufferElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLDepthBufferElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLDepthBufferElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLDepthBufferElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLDepthBufferElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLDepthBufferElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoGLDepthBufferElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLDepthBufferElement_pop(self, *args)

SoGLDepthBufferElement_swigregister = _coin.SoGLDepthBufferElement_swigregister
SoGLDepthBufferElement_swigregister(SoGLDepthBufferElement)

def SoGLDepthBufferElement_getClassTypeId():
  """SoGLDepthBufferElement_getClassTypeId() -> SoType"""
  return _coin.SoGLDepthBufferElement_getClassTypeId()

def SoGLDepthBufferElement_getClassStackIndex():
  """SoGLDepthBufferElement_getClassStackIndex() -> int"""
  return _coin.SoGLDepthBufferElement_getClassStackIndex()

def SoGLDepthBufferElement_createInstance():
  """SoGLDepthBufferElement_createInstance() -> void"""
  return _coin.SoGLDepthBufferElement_createInstance()

def SoGLDepthBufferElement_initClass():
  """SoGLDepthBufferElement_initClass()"""
  return _coin.SoGLDepthBufferElement_initClass()

class SoVertexAttributeElement(SoAccumulatedElement):
    """Proxy of C++ SoVertexAttributeElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVertexAttributeElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoVertexAttributeElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoVertexAttributeElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoVertexAttributeElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoVertexAttributeElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoVertexAttributeElement_push(self, *args)

    def add(*args):
        """add(SoState state, SoVertexAttributeData attribdata)"""
        return _coin.SoVertexAttributeElement_add(*args)

    add = staticmethod(add)
    def getInstance(*args):
        """getInstance(SoState state) -> SoVertexAttributeElement"""
        return _coin.SoVertexAttributeElement_getInstance(*args)

    getInstance = staticmethod(getInstance)
    def getNumAttributes(self):
        """getNumAttributes(self) -> unsigned int"""
        return _coin.SoVertexAttributeElement_getNumAttributes(self)

    def applyToAttributes(self, *args):
        """applyToAttributes(self, AttributeApplyFunc func, void closure)"""
        return _coin.SoVertexAttributeElement_applyToAttributes(self, *args)

SoVertexAttributeElement_swigregister = _coin.SoVertexAttributeElement_swigregister
SoVertexAttributeElement_swigregister(SoVertexAttributeElement)

def SoVertexAttributeElement_getClassTypeId():
  """SoVertexAttributeElement_getClassTypeId() -> SoType"""
  return _coin.SoVertexAttributeElement_getClassTypeId()

def SoVertexAttributeElement_getClassStackIndex():
  """SoVertexAttributeElement_getClassStackIndex() -> int"""
  return _coin.SoVertexAttributeElement_getClassStackIndex()

def SoVertexAttributeElement_createInstance():
  """SoVertexAttributeElement_createInstance() -> void"""
  return _coin.SoVertexAttributeElement_createInstance()

def SoVertexAttributeElement_initClass():
  """SoVertexAttributeElement_initClass()"""
  return _coin.SoVertexAttributeElement_initClass()

def SoVertexAttributeElement_add(*args):
  """SoVertexAttributeElement_add(SoState state, SoVertexAttributeData attribdata)"""
  return _coin.SoVertexAttributeElement_add(*args)

def SoVertexAttributeElement_getInstance(*args):
  """SoVertexAttributeElement_getInstance(SoState state) -> SoVertexAttributeElement"""
  return _coin.SoVertexAttributeElement_getInstance(*args)

class SoGLVertexAttributeElement(SoVertexAttributeElement):
    """Proxy of C++ SoGLVertexAttributeElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLVertexAttributeElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLVertexAttributeElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLVertexAttributeElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLVertexAttributeElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLVertexAttributeElement_init(self, *args)

    def enableVBO(self, *args):
        """enableVBO(self, SoGLRenderAction action)"""
        return _coin.SoGLVertexAttributeElement_enableVBO(self, *args)

    def disableVBO(self, *args):
        """disableVBO(self, SoGLRenderAction action)"""
        return _coin.SoGLVertexAttributeElement_disableVBO(self, *args)

    def send(self, *args):
        """send(self, int index)"""
        return _coin.SoGLVertexAttributeElement_send(self, *args)

    def getInstance(*args):
        """getInstance(SoState state) -> SoGLVertexAttributeElement"""
        return _coin.SoGLVertexAttributeElement_getInstance(*args)

    getInstance = staticmethod(getInstance)
SoGLVertexAttributeElement_swigregister = _coin.SoGLVertexAttributeElement_swigregister
SoGLVertexAttributeElement_swigregister(SoGLVertexAttributeElement)

def SoGLVertexAttributeElement_getClassTypeId():
  """SoGLVertexAttributeElement_getClassTypeId() -> SoType"""
  return _coin.SoGLVertexAttributeElement_getClassTypeId()

def SoGLVertexAttributeElement_getClassStackIndex():
  """SoGLVertexAttributeElement_getClassStackIndex() -> int"""
  return _coin.SoGLVertexAttributeElement_getClassStackIndex()

def SoGLVertexAttributeElement_createInstance():
  """SoGLVertexAttributeElement_createInstance() -> void"""
  return _coin.SoGLVertexAttributeElement_createInstance()

def SoGLVertexAttributeElement_initClass():
  """SoGLVertexAttributeElement_initClass()"""
  return _coin.SoGLVertexAttributeElement_initClass()

def SoGLVertexAttributeElement_getInstance(*args):
  """SoGLVertexAttributeElement_getInstance(SoState state) -> SoGLVertexAttributeElement"""
  return _coin.SoGLVertexAttributeElement_getInstance(*args)

class SoVertexAttributeBindingElement(SoInt32Element):
    """Proxy of C++ SoVertexAttributeBindingElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVertexAttributeBindingElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoVertexAttributeBindingElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoVertexAttributeBindingElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoVertexAttributeBindingElement_initClass()

    initClass = staticmethod(initClass)
    OVERALL = _coin.SoVertexAttributeBindingElement_OVERALL
    PER_VERTEX = _coin.SoVertexAttributeBindingElement_PER_VERTEX
    PER_VERTEX_INDEXED = _coin.SoVertexAttributeBindingElement_PER_VERTEX_INDEXED
    DEFAULT = _coin.SoVertexAttributeBindingElement_DEFAULT
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoVertexAttributeBindingElement_init(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, Binding binding)
        set(SoState state, Binding binding)
        """
        return _coin.SoVertexAttributeBindingElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> Binding"""
        return _coin.SoVertexAttributeBindingElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> Binding"""
        return _coin.SoVertexAttributeBindingElement_getDefault()

    getDefault = staticmethod(getDefault)
SoVertexAttributeBindingElement_swigregister = _coin.SoVertexAttributeBindingElement_swigregister
SoVertexAttributeBindingElement_swigregister(SoVertexAttributeBindingElement)

def SoVertexAttributeBindingElement_getClassTypeId():
  """SoVertexAttributeBindingElement_getClassTypeId() -> SoType"""
  return _coin.SoVertexAttributeBindingElement_getClassTypeId()

def SoVertexAttributeBindingElement_getClassStackIndex():
  """SoVertexAttributeBindingElement_getClassStackIndex() -> int"""
  return _coin.SoVertexAttributeBindingElement_getClassStackIndex()

def SoVertexAttributeBindingElement_createInstance():
  """SoVertexAttributeBindingElement_createInstance() -> void"""
  return _coin.SoVertexAttributeBindingElement_createInstance()

def SoVertexAttributeBindingElement_initClass():
  """SoVertexAttributeBindingElement_initClass()"""
  return _coin.SoVertexAttributeBindingElement_initClass()

def SoVertexAttributeBindingElement_set(*args):
  """
    set(SoState state, SoNode node, Binding binding)
    SoVertexAttributeBindingElement_set(SoState state, Binding binding)
    """
  return _coin.SoVertexAttributeBindingElement_set(*args)

def SoVertexAttributeBindingElement_get(*args):
  """SoVertexAttributeBindingElement_get(SoState state) -> Binding"""
  return _coin.SoVertexAttributeBindingElement_get(*args)

def SoVertexAttributeBindingElement_getDefault():
  """SoVertexAttributeBindingElement_getDefault() -> Binding"""
  return _coin.SoVertexAttributeBindingElement_getDefault()

class SoSpecularColorElement(SoReplacedElement):
    """Proxy of C++ SoSpecularColorElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSpecularColorElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoSpecularColorElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSpecularColorElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoSpecularColorElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoSpecularColorElement_init(self, *args)

    def set(*args):
        """set(SoState state, SoNode node, int32_t numColors, SbColor colors)"""
        return _coin.SoSpecularColorElement_set(*args)

    set = staticmethod(set)
    def getInstance(*args):
        """getInstance(SoState state) -> SoSpecularColorElement"""
        return _coin.SoSpecularColorElement_getInstance(*args)

    getInstance = staticmethod(getInstance)
    def getNum(self):
        """getNum(self) -> int32_t"""
        return _coin.SoSpecularColorElement_getNum(self)

    def get(self, *args):
        """get(self, int index) -> SbColor"""
        return _coin.SoSpecularColorElement_get(self, *args)

    def getArrayPtr(self):
        """getArrayPtr(self) -> SbColor"""
        return _coin.SoSpecularColorElement_getArrayPtr(self)

SoSpecularColorElement_swigregister = _coin.SoSpecularColorElement_swigregister
SoSpecularColorElement_swigregister(SoSpecularColorElement)

def SoSpecularColorElement_getClassTypeId():
  """SoSpecularColorElement_getClassTypeId() -> SoType"""
  return _coin.SoSpecularColorElement_getClassTypeId()

def SoSpecularColorElement_getClassStackIndex():
  """SoSpecularColorElement_getClassStackIndex() -> int"""
  return _coin.SoSpecularColorElement_getClassStackIndex()

def SoSpecularColorElement_createInstance():
  """SoSpecularColorElement_createInstance() -> void"""
  return _coin.SoSpecularColorElement_createInstance()

def SoSpecularColorElement_initClass():
  """SoSpecularColorElement_initClass()"""
  return _coin.SoSpecularColorElement_initClass()

def SoSpecularColorElement_set(*args):
  """SoSpecularColorElement_set(SoState state, SoNode node, int32_t numColors, SbColor colors)"""
  return _coin.SoSpecularColorElement_set(*args)

def SoSpecularColorElement_getInstance(*args):
  """SoSpecularColorElement_getInstance(SoState state) -> SoSpecularColorElement"""
  return _coin.SoSpecularColorElement_getInstance(*args)

class SoEmissiveColorElement(SoReplacedElement):
    """Proxy of C++ SoEmissiveColorElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoEmissiveColorElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoEmissiveColorElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoEmissiveColorElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoEmissiveColorElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoEmissiveColorElement_init(self, *args)

    def set(*args):
        """set(SoState state, SoNode node, int32_t numcolors, SbColor colors)"""
        return _coin.SoEmissiveColorElement_set(*args)

    set = staticmethod(set)
    def getInstance(*args):
        """getInstance(SoState state) -> SoEmissiveColorElement"""
        return _coin.SoEmissiveColorElement_getInstance(*args)

    getInstance = staticmethod(getInstance)
    def getNum(self):
        """getNum(self) -> int32_t"""
        return _coin.SoEmissiveColorElement_getNum(self)

    def get(self, *args):
        """get(self, int index) -> SbColor"""
        return _coin.SoEmissiveColorElement_get(self, *args)

    def getArrayPtr(self):
        """getArrayPtr(self) -> SbColor"""
        return _coin.SoEmissiveColorElement_getArrayPtr(self)

SoEmissiveColorElement_swigregister = _coin.SoEmissiveColorElement_swigregister
SoEmissiveColorElement_swigregister(SoEmissiveColorElement)

def SoEmissiveColorElement_getClassTypeId():
  """SoEmissiveColorElement_getClassTypeId() -> SoType"""
  return _coin.SoEmissiveColorElement_getClassTypeId()

def SoEmissiveColorElement_getClassStackIndex():
  """SoEmissiveColorElement_getClassStackIndex() -> int"""
  return _coin.SoEmissiveColorElement_getClassStackIndex()

def SoEmissiveColorElement_createInstance():
  """SoEmissiveColorElement_createInstance() -> void"""
  return _coin.SoEmissiveColorElement_createInstance()

def SoEmissiveColorElement_initClass():
  """SoEmissiveColorElement_initClass()"""
  return _coin.SoEmissiveColorElement_initClass()

def SoEmissiveColorElement_set(*args):
  """SoEmissiveColorElement_set(SoState state, SoNode node, int32_t numcolors, SbColor colors)"""
  return _coin.SoEmissiveColorElement_set(*args)

def SoEmissiveColorElement_getInstance(*args):
  """SoEmissiveColorElement_getInstance(SoState state) -> SoEmissiveColorElement"""
  return _coin.SoEmissiveColorElement_getInstance(*args)

class SoShininessElement(SoReplacedElement):
    """Proxy of C++ SoShininessElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShininessElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoShininessElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoShininessElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoShininessElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoShininessElement_init(self, *args)

    def set(*args):
        """set(SoState state, SoNode node, int32_t numvalues, float values)"""
        return _coin.SoShininessElement_set(*args)

    set = staticmethod(set)
    def getInstance(*args):
        """getInstance(SoState state) -> SoShininessElement"""
        return _coin.SoShininessElement_getInstance(*args)

    getInstance = staticmethod(getInstance)
    def getNum(self):
        """getNum(self) -> int32_t"""
        return _coin.SoShininessElement_getNum(self)

    def get(self, *args):
        """get(self, int index) -> float"""
        return _coin.SoShininessElement_get(self, *args)

    def getArrayPtr(self):
        """getArrayPtr(self) -> float"""
        return _coin.SoShininessElement_getArrayPtr(self)

SoShininessElement_swigregister = _coin.SoShininessElement_swigregister
SoShininessElement_swigregister(SoShininessElement)

def SoShininessElement_getClassTypeId():
  """SoShininessElement_getClassTypeId() -> SoType"""
  return _coin.SoShininessElement_getClassTypeId()

def SoShininessElement_getClassStackIndex():
  """SoShininessElement_getClassStackIndex() -> int"""
  return _coin.SoShininessElement_getClassStackIndex()

def SoShininessElement_createInstance():
  """SoShininessElement_createInstance() -> void"""
  return _coin.SoShininessElement_createInstance()

def SoShininessElement_initClass():
  """SoShininessElement_initClass()"""
  return _coin.SoShininessElement_initClass()

def SoShininessElement_set(*args):
  """SoShininessElement_set(SoState state, SoNode node, int32_t numvalues, float values)"""
  return _coin.SoShininessElement_set(*args)

def SoShininessElement_getInstance(*args):
  """SoShininessElement_getInstance(SoState state) -> SoShininessElement"""
  return _coin.SoShininessElement_getInstance(*args)

class SoTransparencyElement(SoReplacedElement):
    """Proxy of C++ SoTransparencyElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTransparencyElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoTransparencyElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoTransparencyElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoTransparencyElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoTransparencyElement_init(self, *args)

    def set(*args):
        """set(SoState state, SoNode node, int32_t numvalues, float values)"""
        return _coin.SoTransparencyElement_set(*args)

    set = staticmethod(set)
    def getInstance(*args):
        """getInstance(SoState state) -> SoTransparencyElement"""
        return _coin.SoTransparencyElement_getInstance(*args)

    getInstance = staticmethod(getInstance)
    def getNum(self):
        """getNum(self) -> int32_t"""
        return _coin.SoTransparencyElement_getNum(self)

    def get(self, *args):
        """get(self, int index) -> float"""
        return _coin.SoTransparencyElement_get(self, *args)

    def getArrayPtr(self):
        """getArrayPtr(self) -> float"""
        return _coin.SoTransparencyElement_getArrayPtr(self)

SoTransparencyElement_swigregister = _coin.SoTransparencyElement_swigregister
SoTransparencyElement_swigregister(SoTransparencyElement)

def SoTransparencyElement_getClassTypeId():
  """SoTransparencyElement_getClassTypeId() -> SoType"""
  return _coin.SoTransparencyElement_getClassTypeId()

def SoTransparencyElement_getClassStackIndex():
  """SoTransparencyElement_getClassStackIndex() -> int"""
  return _coin.SoTransparencyElement_getClassStackIndex()

def SoTransparencyElement_createInstance():
  """SoTransparencyElement_createInstance() -> void"""
  return _coin.SoTransparencyElement_createInstance()

def SoTransparencyElement_initClass():
  """SoTransparencyElement_initClass()"""
  return _coin.SoTransparencyElement_initClass()

def SoTransparencyElement_set(*args):
  """SoTransparencyElement_set(SoState state, SoNode node, int32_t numvalues, float values)"""
  return _coin.SoTransparencyElement_set(*args)

def SoTransparencyElement_getInstance(*args):
  """SoTransparencyElement_getInstance(SoState state) -> SoTransparencyElement"""
  return _coin.SoTransparencyElement_getInstance(*args)

class SoLightModelElement(SoInt32Element):
    """Proxy of C++ SoLightModelElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoLightModelElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoLightModelElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoLightModelElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoLightModelElement_initClass()

    initClass = staticmethod(initClass)
    BASE_COLOR = _coin.SoLightModelElement_BASE_COLOR
    PHONG = _coin.SoLightModelElement_PHONG
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoLightModelElement_init(self, *args)

    def set(*args):
        """
        set(SoState state, Model model)
        set(SoState state, SoNode node, Model model)
        """
        return _coin.SoLightModelElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> Model"""
        return _coin.SoLightModelElement_get(*args)

    get = staticmethod(get)
    def getDefault():
        """getDefault() -> Model"""
        return _coin.SoLightModelElement_getDefault()

    getDefault = staticmethod(getDefault)
    def getInstance(*args):
        """getInstance(SoState state) -> SoLightModelElement"""
        return _coin.SoLightModelElement_getInstance(*args)

    getInstance = staticmethod(getInstance)
SoLightModelElement_swigregister = _coin.SoLightModelElement_swigregister
SoLightModelElement_swigregister(SoLightModelElement)

def SoLightModelElement_getClassTypeId():
  """SoLightModelElement_getClassTypeId() -> SoType"""
  return _coin.SoLightModelElement_getClassTypeId()

def SoLightModelElement_getClassStackIndex():
  """SoLightModelElement_getClassStackIndex() -> int"""
  return _coin.SoLightModelElement_getClassStackIndex()

def SoLightModelElement_createInstance():
  """SoLightModelElement_createInstance() -> void"""
  return _coin.SoLightModelElement_createInstance()

def SoLightModelElement_initClass():
  """SoLightModelElement_initClass()"""
  return _coin.SoLightModelElement_initClass()

def SoLightModelElement_set(*args):
  """
    set(SoState state, Model model)
    SoLightModelElement_set(SoState state, SoNode node, Model model)
    """
  return _coin.SoLightModelElement_set(*args)

def SoLightModelElement_get(*args):
  """SoLightModelElement_get(SoState state) -> Model"""
  return _coin.SoLightModelElement_get(*args)

def SoLightModelElement_getDefault():
  """SoLightModelElement_getDefault() -> Model"""
  return _coin.SoLightModelElement_getDefault()

def SoLightModelElement_getInstance(*args):
  """SoLightModelElement_getInstance(SoState state) -> SoLightModelElement"""
  return _coin.SoLightModelElement_getInstance(*args)

class SoMultiTextureCoordinateElement(SoElement):
    """Proxy of C++ SoMultiTextureCoordinateElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMultiTextureCoordinateElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoMultiTextureCoordinateElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMultiTextureCoordinateElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoMultiTextureCoordinateElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoMultiTextureCoordinateElement_init(self, *args)

    def setDefault(*args):
        """setDefault(SoState state, SoNode node, int unit)"""
        return _coin.SoMultiTextureCoordinateElement_setDefault(*args)

    setDefault = staticmethod(setDefault)
    def set2(*args):
        """
        set2(SoState state, SoNode node, int unit, int32_t numCoords, 
            SbVec2f coords)
        """
        return _coin.SoMultiTextureCoordinateElement_set2(*args)

    set2 = staticmethod(set2)
    def set3(*args):
        """
        set3(SoState state, SoNode node, int unit, int32_t numCoords, 
            SbVec3f coords)
        """
        return _coin.SoMultiTextureCoordinateElement_set3(*args)

    set3 = staticmethod(set3)
    def set4(*args):
        """
        set4(SoState state, SoNode node, int unit, int32_t numCoords, 
            SbVec4f coords)
        """
        return _coin.SoMultiTextureCoordinateElement_set4(*args)

    set4 = staticmethod(set4)
    def getType(self, *args):
        """
        getType(self, SoState state, int unit) -> CoordType
        getType(self, int unit) -> CoordType
        """
        return _coin.SoMultiTextureCoordinateElement_getType(self, *args)

    def getInstance(*args):
        """getInstance(SoState state) -> SoMultiTextureCoordinateElement"""
        return _coin.SoMultiTextureCoordinateElement_getInstance(*args)

    getInstance = staticmethod(getInstance)
    def get(self, *args):
        """get(self, int unit, SbVec3f point, SbVec3f normal) -> SbVec4f"""
        return _coin.SoMultiTextureCoordinateElement_get(self, *args)

    def getNum(self, *args):
        """getNum(self, int unit) -> int32_t"""
        return _coin.SoMultiTextureCoordinateElement_getNum(self, *args)

    def is2D(self, *args):
        """is2D(self, int unit) -> SbBool"""
        return _coin.SoMultiTextureCoordinateElement_is2D(self, *args)

    def getDimension(self, *args):
        """getDimension(self, int unit) -> int32_t"""
        return _coin.SoMultiTextureCoordinateElement_getDimension(self, *args)

    def get2(self, *args):
        """get2(self, int unit, int index) -> SbVec2f"""
        return _coin.SoMultiTextureCoordinateElement_get2(self, *args)

    def get3(self, *args):
        """get3(self, int unit, int index) -> SbVec3f"""
        return _coin.SoMultiTextureCoordinateElement_get3(self, *args)

    def get4(self, *args):
        """get4(self, int unit, int index) -> SbVec4f"""
        return _coin.SoMultiTextureCoordinateElement_get4(self, *args)

    def getArrayPtr2(self, *args):
        """getArrayPtr2(self, int unit) -> SbVec2f"""
        return _coin.SoMultiTextureCoordinateElement_getArrayPtr2(self, *args)

    def getArrayPtr3(self, *args):
        """getArrayPtr3(self, int unit) -> SbVec3f"""
        return _coin.SoMultiTextureCoordinateElement_getArrayPtr3(self, *args)

    def getArrayPtr4(self, *args):
        """getArrayPtr4(self, int unit) -> SbVec4f"""
        return _coin.SoMultiTextureCoordinateElement_getArrayPtr4(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoMultiTextureCoordinateElement_push(self, *args)

    def matches(self, *args):
        """matches(self, SoElement elem) -> SbBool"""
        return _coin.SoMultiTextureCoordinateElement_matches(self, *args)

    def copyMatchInfo(self):
        """copyMatchInfo(self) -> SoElement"""
        return _coin.SoMultiTextureCoordinateElement_copyMatchInfo(self)

SoMultiTextureCoordinateElement_swigregister = _coin.SoMultiTextureCoordinateElement_swigregister
SoMultiTextureCoordinateElement_swigregister(SoMultiTextureCoordinateElement)

def SoMultiTextureCoordinateElement_getClassTypeId():
  """SoMultiTextureCoordinateElement_getClassTypeId() -> SoType"""
  return _coin.SoMultiTextureCoordinateElement_getClassTypeId()

def SoMultiTextureCoordinateElement_getClassStackIndex():
  """SoMultiTextureCoordinateElement_getClassStackIndex() -> int"""
  return _coin.SoMultiTextureCoordinateElement_getClassStackIndex()

def SoMultiTextureCoordinateElement_createInstance():
  """SoMultiTextureCoordinateElement_createInstance() -> void"""
  return _coin.SoMultiTextureCoordinateElement_createInstance()

def SoMultiTextureCoordinateElement_initClass():
  """SoMultiTextureCoordinateElement_initClass()"""
  return _coin.SoMultiTextureCoordinateElement_initClass()

def SoMultiTextureCoordinateElement_setDefault(*args):
  """SoMultiTextureCoordinateElement_setDefault(SoState state, SoNode node, int unit)"""
  return _coin.SoMultiTextureCoordinateElement_setDefault(*args)

def SoMultiTextureCoordinateElement_set2(*args):
  """
    SoMultiTextureCoordinateElement_set2(SoState state, SoNode node, int unit, int32_t numCoords, 
        SbVec2f coords)
    """
  return _coin.SoMultiTextureCoordinateElement_set2(*args)

def SoMultiTextureCoordinateElement_set3(*args):
  """
    SoMultiTextureCoordinateElement_set3(SoState state, SoNode node, int unit, int32_t numCoords, 
        SbVec3f coords)
    """
  return _coin.SoMultiTextureCoordinateElement_set3(*args)

def SoMultiTextureCoordinateElement_set4(*args):
  """
    SoMultiTextureCoordinateElement_set4(SoState state, SoNode node, int unit, int32_t numCoords, 
        SbVec4f coords)
    """
  return _coin.SoMultiTextureCoordinateElement_set4(*args)

def SoMultiTextureCoordinateElement_getInstance(*args):
  """SoMultiTextureCoordinateElement_getInstance(SoState state) -> SoMultiTextureCoordinateElement"""
  return _coin.SoMultiTextureCoordinateElement_getInstance(*args)

class SoGLMultiTextureCoordinateElement(SoMultiTextureCoordinateElement):
    """Proxy of C++ SoGLMultiTextureCoordinateElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLMultiTextureCoordinateElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLMultiTextureCoordinateElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLMultiTextureCoordinateElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLMultiTextureCoordinateElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLMultiTextureCoordinateElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoGLMultiTextureCoordinateElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLMultiTextureCoordinateElement_pop(self, *args)

    def getType(self, *args):
        """getType(self, int unit) -> CoordType"""
        return _coin.SoGLMultiTextureCoordinateElement_getType(self, *args)

    def getInstance(*args):
        """getInstance(SoState state) -> SoGLMultiTextureCoordinateElement"""
        return _coin.SoGLMultiTextureCoordinateElement_getInstance(*args)

    getInstance = staticmethod(getInstance)
    def send(self, *args):
        """
        send(self, int unit, int index)
        send(self, int unit, int index, SbVec3f c, SbVec3f n)
        """
        return _coin.SoGLMultiTextureCoordinateElement_send(self, *args)

    def initRender(self, *args):
        """initRender(self, SbBool enabled, int maxenabled)"""
        return _coin.SoGLMultiTextureCoordinateElement_initRender(self, *args)

SoGLMultiTextureCoordinateElement_swigregister = _coin.SoGLMultiTextureCoordinateElement_swigregister
SoGLMultiTextureCoordinateElement_swigregister(SoGLMultiTextureCoordinateElement)

def SoGLMultiTextureCoordinateElement_getClassTypeId():
  """SoGLMultiTextureCoordinateElement_getClassTypeId() -> SoType"""
  return _coin.SoGLMultiTextureCoordinateElement_getClassTypeId()

def SoGLMultiTextureCoordinateElement_getClassStackIndex():
  """SoGLMultiTextureCoordinateElement_getClassStackIndex() -> int"""
  return _coin.SoGLMultiTextureCoordinateElement_getClassStackIndex()

def SoGLMultiTextureCoordinateElement_createInstance():
  """SoGLMultiTextureCoordinateElement_createInstance() -> void"""
  return _coin.SoGLMultiTextureCoordinateElement_createInstance()

def SoGLMultiTextureCoordinateElement_initClass():
  """SoGLMultiTextureCoordinateElement_initClass()"""
  return _coin.SoGLMultiTextureCoordinateElement_initClass()

def SoGLMultiTextureCoordinateElement_getInstance(*args):
  """SoGLMultiTextureCoordinateElement_getInstance(SoState state) -> SoGLMultiTextureCoordinateElement"""
  return _coin.SoGLMultiTextureCoordinateElement_getInstance(*args)

class SoMultiTextureEnabledElement(SoElement):
    """Proxy of C++ SoMultiTextureEnabledElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMultiTextureEnabledElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoMultiTextureEnabledElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMultiTextureEnabledElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoMultiTextureEnabledElement_initClass()

    initClass = staticmethod(initClass)
    DISABLED = _coin.SoMultiTextureEnabledElement_DISABLED
    TEXTURE2D = _coin.SoMultiTextureEnabledElement_TEXTURE2D
    RECTANGLE = _coin.SoMultiTextureEnabledElement_RECTANGLE
    CUBEMAP = _coin.SoMultiTextureEnabledElement_CUBEMAP
    TEXTURE3D = _coin.SoMultiTextureEnabledElement_TEXTURE3D
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoMultiTextureEnabledElement_init(self, *args)

    def set(*args):
        """set(SoState state, SoNode node, int unit, SbBool enabled)"""
        return _coin.SoMultiTextureEnabledElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state, int unit) -> SbBool"""
        return _coin.SoMultiTextureEnabledElement_get(*args)

    get = staticmethod(get)
    def setElt(self, *args):
        """setElt(self, int unit, int mode)"""
        return _coin.SoMultiTextureEnabledElement_setElt(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoMultiTextureEnabledElement_push(self, *args)

    def matches(self, *args):
        """matches(self, SoElement elem) -> SbBool"""
        return _coin.SoMultiTextureEnabledElement_matches(self, *args)

    def copyMatchInfo(self):
        """copyMatchInfo(self) -> SoElement"""
        return _coin.SoMultiTextureEnabledElement_copyMatchInfo(self)

    def getEnabledUnits(*args):
        """getEnabledUnits(SoState state, int lastenabled) -> SbBool"""
        return _coin.SoMultiTextureEnabledElement_getEnabledUnits(*args)

    getEnabledUnits = staticmethod(getEnabledUnits)
    def getActiveUnits(*args):
        """getActiveUnits(SoState state, int lastenabled) -> Mode"""
        return _coin.SoMultiTextureEnabledElement_getActiveUnits(*args)

    getActiveUnits = staticmethod(getActiveUnits)
    def enableRectangle(*args):
        """enableRectangle(SoState state, SoNode node, int unit)"""
        return _coin.SoMultiTextureEnabledElement_enableRectangle(*args)

    enableRectangle = staticmethod(enableRectangle)
    def enableCubeMap(*args):
        """enableCubeMap(SoState state, SoNode node, int unit)"""
        return _coin.SoMultiTextureEnabledElement_enableCubeMap(*args)

    enableCubeMap = staticmethod(enableCubeMap)
    def getMode(*args):
        """getMode(SoState state, int unit) -> Mode"""
        return _coin.SoMultiTextureEnabledElement_getMode(*args)

    getMode = staticmethod(getMode)
    def disableAll(*args):
        """disableAll(SoState state)"""
        return _coin.SoMultiTextureEnabledElement_disableAll(*args)

    disableAll = staticmethod(disableAll)
SoMultiTextureEnabledElement_swigregister = _coin.SoMultiTextureEnabledElement_swigregister
SoMultiTextureEnabledElement_swigregister(SoMultiTextureEnabledElement)

def SoMultiTextureEnabledElement_getClassTypeId():
  """SoMultiTextureEnabledElement_getClassTypeId() -> SoType"""
  return _coin.SoMultiTextureEnabledElement_getClassTypeId()

def SoMultiTextureEnabledElement_getClassStackIndex():
  """SoMultiTextureEnabledElement_getClassStackIndex() -> int"""
  return _coin.SoMultiTextureEnabledElement_getClassStackIndex()

def SoMultiTextureEnabledElement_createInstance():
  """SoMultiTextureEnabledElement_createInstance() -> void"""
  return _coin.SoMultiTextureEnabledElement_createInstance()

def SoMultiTextureEnabledElement_initClass():
  """SoMultiTextureEnabledElement_initClass()"""
  return _coin.SoMultiTextureEnabledElement_initClass()

def SoMultiTextureEnabledElement_set(*args):
  """SoMultiTextureEnabledElement_set(SoState state, SoNode node, int unit, SbBool enabled)"""
  return _coin.SoMultiTextureEnabledElement_set(*args)

def SoMultiTextureEnabledElement_get(*args):
  """SoMultiTextureEnabledElement_get(SoState state, int unit) -> SbBool"""
  return _coin.SoMultiTextureEnabledElement_get(*args)

def SoMultiTextureEnabledElement_getEnabledUnits(*args):
  """SoMultiTextureEnabledElement_getEnabledUnits(SoState state, int lastenabled) -> SbBool"""
  return _coin.SoMultiTextureEnabledElement_getEnabledUnits(*args)

def SoMultiTextureEnabledElement_getActiveUnits(*args):
  """SoMultiTextureEnabledElement_getActiveUnits(SoState state, int lastenabled) -> Mode"""
  return _coin.SoMultiTextureEnabledElement_getActiveUnits(*args)

def SoMultiTextureEnabledElement_enableRectangle(*args):
  """SoMultiTextureEnabledElement_enableRectangle(SoState state, SoNode node, int unit)"""
  return _coin.SoMultiTextureEnabledElement_enableRectangle(*args)

def SoMultiTextureEnabledElement_enableCubeMap(*args):
  """SoMultiTextureEnabledElement_enableCubeMap(SoState state, SoNode node, int unit)"""
  return _coin.SoMultiTextureEnabledElement_enableCubeMap(*args)

def SoMultiTextureEnabledElement_getMode(*args):
  """SoMultiTextureEnabledElement_getMode(SoState state, int unit) -> Mode"""
  return _coin.SoMultiTextureEnabledElement_getMode(*args)

def SoMultiTextureEnabledElement_disableAll(*args):
  """SoMultiTextureEnabledElement_disableAll(SoState state)"""
  return _coin.SoMultiTextureEnabledElement_disableAll(*args)

class SoGLMultiTextureEnabledElement(SoMultiTextureEnabledElement):
    """Proxy of C++ SoGLMultiTextureEnabledElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLMultiTextureEnabledElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLMultiTextureEnabledElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLMultiTextureEnabledElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLMultiTextureEnabledElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLMultiTextureEnabledElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoGLMultiTextureEnabledElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLMultiTextureEnabledElement_pop(self, *args)

    def setElt(self, *args):
        """setElt(self, int unit, int mode)"""
        return _coin.SoGLMultiTextureEnabledElement_setElt(self, *args)

SoGLMultiTextureEnabledElement_swigregister = _coin.SoGLMultiTextureEnabledElement_swigregister
SoGLMultiTextureEnabledElement_swigregister(SoGLMultiTextureEnabledElement)

def SoGLMultiTextureEnabledElement_getClassTypeId():
  """SoGLMultiTextureEnabledElement_getClassTypeId() -> SoType"""
  return _coin.SoGLMultiTextureEnabledElement_getClassTypeId()

def SoGLMultiTextureEnabledElement_getClassStackIndex():
  """SoGLMultiTextureEnabledElement_getClassStackIndex() -> int"""
  return _coin.SoGLMultiTextureEnabledElement_getClassStackIndex()

def SoGLMultiTextureEnabledElement_createInstance():
  """SoGLMultiTextureEnabledElement_createInstance() -> void"""
  return _coin.SoGLMultiTextureEnabledElement_createInstance()

def SoGLMultiTextureEnabledElement_initClass():
  """SoGLMultiTextureEnabledElement_initClass()"""
  return _coin.SoGLMultiTextureEnabledElement_initClass()

class SoMultiTextureImageElement(SoElement):
    """Proxy of C++ SoMultiTextureImageElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMultiTextureImageElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoMultiTextureImageElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMultiTextureImageElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoMultiTextureImageElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoMultiTextureImageElement_init(self, *args)

    def setDefault(*args):
        """setDefault(SoState state, SoNode node, int unit)"""
        return _coin.SoMultiTextureImageElement_setDefault(*args)

    setDefault = staticmethod(setDefault)
    def set(*args):
        """
        set(SoState state, SoNode node, int unit, SbVec2s size, 
            int numComponents, unsigned char bytes, Wrap wrapS, 
            Wrap wrapT, Model model, SbColor blendColor)
        set(SoState state, SoNode node, int unit, SbVec3s size, 
            int numComponents, unsigned char bytes, Wrap wrapS, 
            Wrap wrapT, Wrap wrapR, Model model, 
            SbColor blendColor)
        """
        return _coin.SoMultiTextureImageElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """
        get(SoState state, int unit, SbVec2s size, int numComponents, 
            Wrap wrapS, Wrap wrapT, Model model, SbColor blendColor) -> unsigned char
        get(SoState state, int unit, SbVec3s size, int numComponents, 
            Wrap wrapS, Wrap wrapT, Wrap wrapR, Model model, 
            SbColor blendColor) -> unsigned char
        """
        return _coin.SoMultiTextureImageElement_get(*args)

    get = staticmethod(get)
    def getImage(*args):
        """
        getImage(SoState state, int unit, SbVec2s size, int numComponents) -> unsigned char
        getImage(SoState state, int unit, SbVec3s size, int numComponents) -> unsigned char
        """
        return _coin.SoMultiTextureImageElement_getImage(*args)

    getImage = staticmethod(getImage)
    def getBlendColor(*args):
        """getBlendColor(SoState state, int unit) -> SbColor"""
        return _coin.SoMultiTextureImageElement_getBlendColor(*args)

    getBlendColor = staticmethod(getBlendColor)
    def getModel(*args):
        """getModel(SoState state, int unit) -> Model"""
        return _coin.SoMultiTextureImageElement_getModel(*args)

    getModel = staticmethod(getModel)
    def getWrapS(*args):
        """getWrapS(SoState state, int unit) -> Wrap"""
        return _coin.SoMultiTextureImageElement_getWrapS(*args)

    getWrapS = staticmethod(getWrapS)
    def getWrapT(*args):
        """getWrapT(SoState state, int unit) -> Wrap"""
        return _coin.SoMultiTextureImageElement_getWrapT(*args)

    getWrapT = staticmethod(getWrapT)
    def getWrapR(*args):
        """getWrapR(SoState state, int unit) -> Wrap"""
        return _coin.SoMultiTextureImageElement_getWrapR(*args)

    getWrapR = staticmethod(getWrapR)
    def containsTransparency(*args):
        """containsTransparency(SoState state) -> SbBool"""
        return _coin.SoMultiTextureImageElement_containsTransparency(*args)

    containsTransparency = staticmethod(containsTransparency)
    def getDefault(*args):
        """
        getDefault(SbVec2s size, int numComponents) -> unsigned char
        getDefault(SbVec3s size, int numComponents) -> unsigned char
        """
        return _coin.SoMultiTextureImageElement_getDefault(*args)

    getDefault = staticmethod(getDefault)
    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoMultiTextureImageElement_push(self, *args)

    def matches(self, *args):
        """matches(self, SoElement elem) -> SbBool"""
        return _coin.SoMultiTextureImageElement_matches(self, *args)

    def copyMatchInfo(self):
        """copyMatchInfo(self) -> SoElement"""
        return _coin.SoMultiTextureImageElement_copyMatchInfo(self)

    def setElt(self, *args):
        """
        setElt(self, int unit, uint32_t nodeid, SbVec2s size, int numComponents, 
            unsigned char bytes, Wrap wrapS, Wrap wrapT, 
            Model model, SbColor blendColor)
        setElt(self, int unit, uint32_t nodeid, SbVec3s size, int numComponents, 
            unsigned char bytes, Wrap wrapS, Wrap wrapT, 
            Wrap wrapR, Model model, SbColor blendColor)
        """
        return _coin.SoMultiTextureImageElement_setElt(self, *args)

    def hasTransparency(self, *args):
        """hasTransparency(self, int unit) -> SbBool"""
        return _coin.SoMultiTextureImageElement_hasTransparency(self, *args)

SoMultiTextureImageElement_swigregister = _coin.SoMultiTextureImageElement_swigregister
SoMultiTextureImageElement_swigregister(SoMultiTextureImageElement)

def SoMultiTextureImageElement_getClassTypeId():
  """SoMultiTextureImageElement_getClassTypeId() -> SoType"""
  return _coin.SoMultiTextureImageElement_getClassTypeId()

def SoMultiTextureImageElement_getClassStackIndex():
  """SoMultiTextureImageElement_getClassStackIndex() -> int"""
  return _coin.SoMultiTextureImageElement_getClassStackIndex()

def SoMultiTextureImageElement_createInstance():
  """SoMultiTextureImageElement_createInstance() -> void"""
  return _coin.SoMultiTextureImageElement_createInstance()

def SoMultiTextureImageElement_initClass():
  """SoMultiTextureImageElement_initClass()"""
  return _coin.SoMultiTextureImageElement_initClass()

def SoMultiTextureImageElement_setDefault(*args):
  """SoMultiTextureImageElement_setDefault(SoState state, SoNode node, int unit)"""
  return _coin.SoMultiTextureImageElement_setDefault(*args)

def SoMultiTextureImageElement_set(*args):
  """
    set(SoState state, SoNode node, int unit, SbVec2s size, 
        int numComponents, unsigned char bytes, Wrap wrapS, 
        Wrap wrapT, Model model, SbColor blendColor)
    SoMultiTextureImageElement_set(SoState state, SoNode node, int unit, SbVec3s size, 
        int numComponents, unsigned char bytes, Wrap wrapS, 
        Wrap wrapT, Wrap wrapR, Model model, 
        SbColor blendColor)
    """
  return _coin.SoMultiTextureImageElement_set(*args)

def SoMultiTextureImageElement_get(*args):
  """
    get(SoState state, int unit, SbVec2s size, int numComponents, 
        Wrap wrapS, Wrap wrapT, Model model, SbColor blendColor) -> unsigned char
    SoMultiTextureImageElement_get(SoState state, int unit, SbVec3s size, int numComponents, 
        Wrap wrapS, Wrap wrapT, Wrap wrapR, Model model, 
        SbColor blendColor) -> unsigned char
    """
  return _coin.SoMultiTextureImageElement_get(*args)

def SoMultiTextureImageElement_getImage(*args):
  """
    getImage(SoState state, int unit, SbVec2s size, int numComponents) -> unsigned char
    SoMultiTextureImageElement_getImage(SoState state, int unit, SbVec3s size, int numComponents) -> unsigned char
    """
  return _coin.SoMultiTextureImageElement_getImage(*args)

def SoMultiTextureImageElement_getBlendColor(*args):
  """SoMultiTextureImageElement_getBlendColor(SoState state, int unit) -> SbColor"""
  return _coin.SoMultiTextureImageElement_getBlendColor(*args)

def SoMultiTextureImageElement_getModel(*args):
  """SoMultiTextureImageElement_getModel(SoState state, int unit) -> Model"""
  return _coin.SoMultiTextureImageElement_getModel(*args)

def SoMultiTextureImageElement_getWrapS(*args):
  """SoMultiTextureImageElement_getWrapS(SoState state, int unit) -> Wrap"""
  return _coin.SoMultiTextureImageElement_getWrapS(*args)

def SoMultiTextureImageElement_getWrapT(*args):
  """SoMultiTextureImageElement_getWrapT(SoState state, int unit) -> Wrap"""
  return _coin.SoMultiTextureImageElement_getWrapT(*args)

def SoMultiTextureImageElement_getWrapR(*args):
  """SoMultiTextureImageElement_getWrapR(SoState state, int unit) -> Wrap"""
  return _coin.SoMultiTextureImageElement_getWrapR(*args)

def SoMultiTextureImageElement_containsTransparency(*args):
  """SoMultiTextureImageElement_containsTransparency(SoState state) -> SbBool"""
  return _coin.SoMultiTextureImageElement_containsTransparency(*args)

def SoMultiTextureImageElement_getDefault(*args):
  """
    getDefault(SbVec2s size, int numComponents) -> unsigned char
    SoMultiTextureImageElement_getDefault(SbVec3s size, int numComponents) -> unsigned char
    """
  return _coin.SoMultiTextureImageElement_getDefault(*args)

class SoGLMultiTextureImageElement(SoMultiTextureImageElement):
    """Proxy of C++ SoGLMultiTextureImageElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLMultiTextureImageElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLMultiTextureImageElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLMultiTextureImageElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLMultiTextureImageElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLMultiTextureImageElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoGLMultiTextureImageElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLMultiTextureImageElement_pop(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, int unit, SoGLImage image, 
            Model model, SbColor blendColor)
        """
        return _coin.SoGLMultiTextureImageElement_set(*args)

    set = staticmethod(set)
    def restore(*args):
        """restore(SoState state, int unit)"""
        return _coin.SoGLMultiTextureImageElement_restore(*args)

    restore = staticmethod(restore)
    def get(*args):
        """get(SoState state, int unit, Model model, SbColor blendcolor) -> SoGLImage"""
        return _coin.SoGLMultiTextureImageElement_get(*args)

    get = staticmethod(get)
    def hasTransparency(*args):
        """hasTransparency(SoState state) -> SbBool"""
        return _coin.SoGLMultiTextureImageElement_hasTransparency(*args)

    hasTransparency = staticmethod(hasTransparency)
SoGLMultiTextureImageElement_swigregister = _coin.SoGLMultiTextureImageElement_swigregister
SoGLMultiTextureImageElement_swigregister(SoGLMultiTextureImageElement)

def SoGLMultiTextureImageElement_getClassTypeId():
  """SoGLMultiTextureImageElement_getClassTypeId() -> SoType"""
  return _coin.SoGLMultiTextureImageElement_getClassTypeId()

def SoGLMultiTextureImageElement_getClassStackIndex():
  """SoGLMultiTextureImageElement_getClassStackIndex() -> int"""
  return _coin.SoGLMultiTextureImageElement_getClassStackIndex()

def SoGLMultiTextureImageElement_createInstance():
  """SoGLMultiTextureImageElement_createInstance() -> void"""
  return _coin.SoGLMultiTextureImageElement_createInstance()

def SoGLMultiTextureImageElement_initClass():
  """SoGLMultiTextureImageElement_initClass()"""
  return _coin.SoGLMultiTextureImageElement_initClass()

def SoGLMultiTextureImageElement_set(*args):
  """
    SoGLMultiTextureImageElement_set(SoState state, SoNode node, int unit, SoGLImage image, 
        Model model, SbColor blendColor)
    """
  return _coin.SoGLMultiTextureImageElement_set(*args)

def SoGLMultiTextureImageElement_restore(*args):
  """SoGLMultiTextureImageElement_restore(SoState state, int unit)"""
  return _coin.SoGLMultiTextureImageElement_restore(*args)

def SoGLMultiTextureImageElement_get(*args):
  """SoGLMultiTextureImageElement_get(SoState state, int unit, Model model, SbColor blendcolor) -> SoGLImage"""
  return _coin.SoGLMultiTextureImageElement_get(*args)

def SoGLMultiTextureImageElement_hasTransparency(*args):
  """SoGLMultiTextureImageElement_hasTransparency(SoState state) -> SbBool"""
  return _coin.SoGLMultiTextureImageElement_hasTransparency(*args)

class SoMultiTextureMatrixElement(SoAccumulatedElement):
    """Proxy of C++ SoMultiTextureMatrixElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMultiTextureMatrixElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoMultiTextureMatrixElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMultiTextureMatrixElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoMultiTextureMatrixElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoMultiTextureMatrixElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoMultiTextureMatrixElement_push(self, *args)

    def set(*args):
        """set(SoState state, SoNode node, int unit)"""
        return _coin.SoMultiTextureMatrixElement_set(*args)

    set = staticmethod(set)
    def mult(*args):
        """mult(SoState state, SoNode node, int unit)"""
        return _coin.SoMultiTextureMatrixElement_mult(*args)

    mult = staticmethod(mult)
    def get(*args):
        """get(SoState state, int unit) -> SbMatrix"""
        return _coin.SoMultiTextureMatrixElement_get(*args)

    get = staticmethod(get)
SoMultiTextureMatrixElement_swigregister = _coin.SoMultiTextureMatrixElement_swigregister
SoMultiTextureMatrixElement_swigregister(SoMultiTextureMatrixElement)

def SoMultiTextureMatrixElement_getClassTypeId():
  """SoMultiTextureMatrixElement_getClassTypeId() -> SoType"""
  return _coin.SoMultiTextureMatrixElement_getClassTypeId()

def SoMultiTextureMatrixElement_getClassStackIndex():
  """SoMultiTextureMatrixElement_getClassStackIndex() -> int"""
  return _coin.SoMultiTextureMatrixElement_getClassStackIndex()

def SoMultiTextureMatrixElement_createInstance():
  """SoMultiTextureMatrixElement_createInstance() -> void"""
  return _coin.SoMultiTextureMatrixElement_createInstance()

def SoMultiTextureMatrixElement_initClass():
  """SoMultiTextureMatrixElement_initClass()"""
  return _coin.SoMultiTextureMatrixElement_initClass()

def SoMultiTextureMatrixElement_set(*args):
  """SoMultiTextureMatrixElement_set(SoState state, SoNode node, int unit)"""
  return _coin.SoMultiTextureMatrixElement_set(*args)

def SoMultiTextureMatrixElement_mult(*args):
  """SoMultiTextureMatrixElement_mult(SoState state, SoNode node, int unit)"""
  return _coin.SoMultiTextureMatrixElement_mult(*args)

def SoMultiTextureMatrixElement_get(*args):
  """SoMultiTextureMatrixElement_get(SoState state, int unit) -> SbMatrix"""
  return _coin.SoMultiTextureMatrixElement_get(*args)

class SoGLMultiTextureMatrixElement(SoMultiTextureMatrixElement):
    """Proxy of C++ SoGLMultiTextureMatrixElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLMultiTextureMatrixElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoGLMultiTextureMatrixElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGLMultiTextureMatrixElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGLMultiTextureMatrixElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoGLMultiTextureMatrixElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoGLMultiTextureMatrixElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLMultiTextureMatrixElement_pop(self, *args)

    def multElt(self, *args):
        """multElt(self, int unit)"""
        return _coin.SoGLMultiTextureMatrixElement_multElt(self, *args)

    def setElt(self, *args):
        """setElt(self, int unit)"""
        return _coin.SoGLMultiTextureMatrixElement_setElt(self, *args)

SoGLMultiTextureMatrixElement_swigregister = _coin.SoGLMultiTextureMatrixElement_swigregister
SoGLMultiTextureMatrixElement_swigregister(SoGLMultiTextureMatrixElement)

def SoGLMultiTextureMatrixElement_getClassTypeId():
  """SoGLMultiTextureMatrixElement_getClassTypeId() -> SoType"""
  return _coin.SoGLMultiTextureMatrixElement_getClassTypeId()

def SoGLMultiTextureMatrixElement_getClassStackIndex():
  """SoGLMultiTextureMatrixElement_getClassStackIndex() -> int"""
  return _coin.SoGLMultiTextureMatrixElement_getClassStackIndex()

def SoGLMultiTextureMatrixElement_createInstance():
  """SoGLMultiTextureMatrixElement_createInstance() -> void"""
  return _coin.SoGLMultiTextureMatrixElement_createInstance()

def SoGLMultiTextureMatrixElement_initClass():
  """SoGLMultiTextureMatrixElement_initClass()"""
  return _coin.SoGLMultiTextureMatrixElement_initClass()

class SbColor4f(SbVec4f):
    """Proxy of C++ SbColor4f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbColor4f
        __init__(self, SbColor rgb, float alpha) -> SbColor4f
        __init__(self, SbVec4f v) -> SbColor4f
        __init__(self, float rgba) -> SbColor4f
        __init__(self, float r, float g, float b, float a = 1.0) -> SbColor4f
        __init__(self, float r, float g, float b) -> SbColor4f
        """
        this = _coin.new_SbColor4f(*args)
        try: self.this.append(this)
        except: self.this = this
    def setValue(self, *args):
        """
        setValue(self, float r, float g, float b, float a = 1.0)
        setValue(self, float r, float g, float b)
        setValue(self, float col)
        """
        return _coin.SbColor4f_setValue(self, *args)

    def getValue(self):
        """getValue(self)"""
        return _coin.SbColor4f_getValue(self)

    def setRGB(self, *args):
        """setRGB(self, SbColor col) -> SbColor4f"""
        return _coin.SbColor4f_setRGB(self, *args)

    def getRGB(self, *args):
        """getRGB(self, SbColor color)"""
        return _coin.SbColor4f_getRGB(self, *args)

    def setHSVValue(self, *args):
        """
        setHSVValue(self, float h, float s, float v, float a = 1.0) -> SbColor4f
        setHSVValue(self, float h, float s, float v) -> SbColor4f
        setHSVValue(self, float hsv, float alpha = 1.0) -> SbColor4f
        setHSVValue(self, float hsv) -> SbColor4f
        """
        return _coin.SbColor4f_setHSVValue(self, *args)

    def getHSVValue(self):
        """getHSVValue(self)"""
        return _coin.SbColor4f_getHSVValue(self)

    def setPackedValue(self, *args):
        """setPackedValue(self, uint32_t rgba) -> SbColor4f"""
        return _coin.SbColor4f_setPackedValue(self, *args)

    def getPackedValue(self):
        """getPackedValue(self) -> uint32_t"""
        return _coin.SbColor4f_getPackedValue(self)

    def __imul__(self, *args):
        """__imul__(self, float d) -> SbColor4f"""
        return _coin.SbColor4f___imul__(self, *args)

    def __idiv__(self, *args):
        """__idiv__(self, float d) -> SbColor4f"""
        return _coin.SbColor4f___idiv__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, SbColor4f c) -> SbColor4f"""
        return _coin.SbColor4f___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, SbColor4f c) -> SbColor4f"""
        return _coin.SbColor4f___isub__(self, *args)

    def __add__(self, *args):
        """__add__(self, SbColor4f u) -> SbColor4f"""
        return _coin.SbColor4f___add__(self, *args)

    def __sub__(self, *args):
        """__sub__(self, SbColor4f u) -> SbColor4f"""
        return _coin.SbColor4f___sub__(self, *args)

    def __mul__(self, *args):
        """__mul__(self, float d) -> SbColor4f"""
        return _coin.SbColor4f___mul__(self, *args)

    def __rmul__(self, *args):
        """__rmul__(self, float d) -> SbColor4f"""
        return _coin.SbColor4f___rmul__(self, *args)

    def __div__(self, *args):
        """__div__(self, float d) -> SbColor4f"""
        return _coin.SbColor4f___div__(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SbColor4f u) -> int"""
        return _coin.SbColor4f___eq__(self, *args)

    def __nq__(self, *args):
        """__nq__(self, SbColor4f u) -> int"""
        return _coin.SbColor4f___nq__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> float"""
        return _coin.SbColor4f___getitem__(self, *args)

    __swig_destroy__ = _coin.delete_SbColor4f
    __del__ = lambda self : None;
SbColor4f_swigregister = _coin.SbColor4f_swigregister
SbColor4f_swigregister(SbColor4f)

class SoTextureCombineElement(SoElement):
    """Proxy of C++ SoTextureCombineElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextureCombineElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoTextureCombineElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoTextureCombineElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoTextureCombineElement_initClass()

    initClass = staticmethod(initClass)
    PRIMARY_COLOR = _coin.SoTextureCombineElement_PRIMARY_COLOR
    TEXTURE = _coin.SoTextureCombineElement_TEXTURE
    CONSTANT = _coin.SoTextureCombineElement_CONSTANT
    PREVIOUS = _coin.SoTextureCombineElement_PREVIOUS
    SRC_COLOR = _coin.SoTextureCombineElement_SRC_COLOR
    ONE_MINUS_SRC_COLOR = _coin.SoTextureCombineElement_ONE_MINUS_SRC_COLOR
    SRC_ALPHA = _coin.SoTextureCombineElement_SRC_ALPHA
    ONE_MINUS_SRC_ALPHA = _coin.SoTextureCombineElement_ONE_MINUS_SRC_ALPHA
    REPLACE = _coin.SoTextureCombineElement_REPLACE
    MODULATE = _coin.SoTextureCombineElement_MODULATE
    ADD = _coin.SoTextureCombineElement_ADD
    ADD_SIGNED = _coin.SoTextureCombineElement_ADD_SIGNED
    SUBTRACT = _coin.SoTextureCombineElement_SUBTRACT
    INTERPOLATE = _coin.SoTextureCombineElement_INTERPOLATE
    DOT3_RGB = _coin.SoTextureCombineElement_DOT3_RGB
    DOT3_RGBA = _coin.SoTextureCombineElement_DOT3_RGBA
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoTextureCombineElement_init(self, *args)

    def set(*args):
        """
        set(SoState state, SoNode node, int unit, Operation rgboperation, 
            Operation alphaoperation, Source rgbsource, 
            Source alphasource, Operand rgboperand, 
            Operand alphaoperand, SbColor4f constantcolor, 
            float rgbscale, float alphascale)
        """
        return _coin.SoTextureCombineElement_set(*args)

    set = staticmethod(set)
    def isDefault(*args):
        """isDefault(SoState state, int unit) -> SbBool"""
        return _coin.SoTextureCombineElement_isDefault(*args)

    isDefault = staticmethod(isDefault)
    def get(*args):
        """
        get(SoState state, int unit, Operation rgboperation, Operation alphaoperation, 
            Source rgbsource, Source alphasource, 
            Operand rgboperand, Operand alphaoperand, 
            SbColor4f constantcolor, float rgbscale, 
            float alphascale)
        """
        return _coin.SoTextureCombineElement_get(*args)

    get = staticmethod(get)
    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoTextureCombineElement_push(self, *args)

    def matches(self, *args):
        """matches(self, SoElement elem) -> SbBool"""
        return _coin.SoTextureCombineElement_matches(self, *args)

    def copyMatchInfo(self):
        """copyMatchInfo(self) -> SoElement"""
        return _coin.SoTextureCombineElement_copyMatchInfo(self)

    def setElt(self, *args):
        """
        setElt(self, int unit, uint32_t nodeid, Operation rgboperation, 
            Operation alphaoperation, Source rgbsource, Source alphasource, 
            Operand rgboperand, Operand alphaoperand, 
            SbColor4f constantcolor, float rgbscale, 
            float alphascale)
        """
        return _coin.SoTextureCombineElement_setElt(self, *args)

    def apply(*args):
        """apply(SoState state, int unit)"""
        return _coin.SoTextureCombineElement_apply(*args)

    apply = staticmethod(apply)
SoTextureCombineElement_swigregister = _coin.SoTextureCombineElement_swigregister
SoTextureCombineElement_swigregister(SoTextureCombineElement)

def SoTextureCombineElement_getClassTypeId():
  """SoTextureCombineElement_getClassTypeId() -> SoType"""
  return _coin.SoTextureCombineElement_getClassTypeId()

def SoTextureCombineElement_getClassStackIndex():
  """SoTextureCombineElement_getClassStackIndex() -> int"""
  return _coin.SoTextureCombineElement_getClassStackIndex()

def SoTextureCombineElement_createInstance():
  """SoTextureCombineElement_createInstance() -> void"""
  return _coin.SoTextureCombineElement_createInstance()

def SoTextureCombineElement_initClass():
  """SoTextureCombineElement_initClass()"""
  return _coin.SoTextureCombineElement_initClass()

def SoTextureCombineElement_set(*args):
  """
    SoTextureCombineElement_set(SoState state, SoNode node, int unit, Operation rgboperation, 
        Operation alphaoperation, Source rgbsource, 
        Source alphasource, Operand rgboperand, 
        Operand alphaoperand, SbColor4f constantcolor, 
        float rgbscale, float alphascale)
    """
  return _coin.SoTextureCombineElement_set(*args)

def SoTextureCombineElement_isDefault(*args):
  """SoTextureCombineElement_isDefault(SoState state, int unit) -> SbBool"""
  return _coin.SoTextureCombineElement_isDefault(*args)

def SoTextureCombineElement_get(*args):
  """
    SoTextureCombineElement_get(SoState state, int unit, Operation rgboperation, Operation alphaoperation, 
        Source rgbsource, Source alphasource, 
        Operand rgboperand, Operand alphaoperand, 
        SbColor4f constantcolor, float rgbscale, 
        float alphascale)
    """
  return _coin.SoTextureCombineElement_get(*args)

def SoTextureCombineElement_apply(*args):
  """SoTextureCombineElement_apply(SoState state, int unit)"""
  return _coin.SoTextureCombineElement_apply(*args)

class SoTextureUnitElement(SoInt32Element):
    """Proxy of C++ SoTextureUnitElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextureUnitElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoTextureUnitElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoTextureUnitElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoTextureUnitElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoTextureUnitElement_init(self, *args)

    def set(*args):
        """set(SoState state, SoNode node, int units)"""
        return _coin.SoTextureUnitElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state) -> int"""
        return _coin.SoTextureUnitElement_get(*args)

    get = staticmethod(get)
SoTextureUnitElement_swigregister = _coin.SoTextureUnitElement_swigregister
SoTextureUnitElement_swigregister(SoTextureUnitElement)

def SoTextureUnitElement_getClassTypeId():
  """SoTextureUnitElement_getClassTypeId() -> SoType"""
  return _coin.SoTextureUnitElement_getClassTypeId()

def SoTextureUnitElement_getClassStackIndex():
  """SoTextureUnitElement_getClassStackIndex() -> int"""
  return _coin.SoTextureUnitElement_getClassStackIndex()

def SoTextureUnitElement_createInstance():
  """SoTextureUnitElement_createInstance() -> void"""
  return _coin.SoTextureUnitElement_createInstance()

def SoTextureUnitElement_initClass():
  """SoTextureUnitElement_initClass()"""
  return _coin.SoTextureUnitElement_initClass()

def SoTextureUnitElement_set(*args):
  """SoTextureUnitElement_set(SoState state, SoNode node, int units)"""
  return _coin.SoTextureUnitElement_set(*args)

def SoTextureUnitElement_get(*args):
  """SoTextureUnitElement_get(SoState state) -> int"""
  return _coin.SoTextureUnitElement_get(*args)

class SoEngine(SoFieldContainer):
    """Proxy of C++ SoEngine class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def initClass():
        """initClass()"""
        return _coin.SoEngine_initClass()

    initClass = staticmethod(initClass)
    def initClasses():
        """initClasses()"""
        return _coin.SoEngine_initClasses()

    initClasses = staticmethod(initClasses)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoEngine_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def evaluateWrapper(self):
        """evaluateWrapper(self)"""
        return _coin.SoEngine_evaluateWrapper(self)

    def getOutputs(self, *args):
        """getOutputs(self, SoEngineOutputList l) -> int"""
        return _coin.SoEngine_getOutputs(self, *args)

    def getOutput(self, *args):
        """getOutput(self, SbName outputname) -> SoEngineOutput"""
        return _coin.SoEngine_getOutput(self, *args)

    def getOutputName(self, *args):
        """getOutputName(self, SoEngineOutput output, SbName outputname) -> SbBool"""
        return _coin.SoEngine_getOutputName(self, *args)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoEngine_getOutputData(self)

    def getByName(*args):
        """
        getByName(SbName name) -> SoEngine
        getByName(SbName name, SoEngineList el) -> int
        """
        return _coin.SoEngine_getByName(*args)

    getByName = staticmethod(getByName)
    def isNotifying(self):
        """isNotifying(self) -> SbBool"""
        return _coin.SoEngine_isNotifying(self)

    def notify(self, *args):
        """notify(self, SoNotList nl)"""
        return _coin.SoEngine_notify(self, *args)

    def copy(self):
        """copy(self) -> SoEngine"""
        return _coin.SoEngine_copy(self)

    def copyThroughConnection(self):
        """copyThroughConnection(self) -> SoFieldContainer"""
        return _coin.SoEngine_copyThroughConnection(self)

    def shouldCopy(self):
        """shouldCopy(self) -> SbBool"""
        return _coin.SoEngine_shouldCopy(self)

    def writeInstance(self, *args):
        """writeInstance(self, SoOutput out)"""
        return _coin.SoEngine_writeInstance(self, *args)

    def __getattr__(self, name):
        try:
            return SoFieldContainer.__getattr__(self, name)
        except AttributeError, e:
            out = self.getOutput(SbName(name))
            if out is None:
                raise e
            return out

    def __setattr__(self,name,value):
        if name == 'this':
            return SoFieldContainer.__setattr__(self, name, value)
        out = self.getOutput(SbName(name))
        if out is None:
            return SoFieldContainer.__setattr__(self, name, value)
        raise AttributeError('Cannot set output %s on engine %s' %(name,self.__class__.__name__))
        

SoEngine_swigregister = _coin.SoEngine_swigregister
SoEngine_swigregister(SoEngine)

def SoEngine_initClass():
  """SoEngine_initClass()"""
  return _coin.SoEngine_initClass()

def SoEngine_initClasses():
  """SoEngine_initClasses()"""
  return _coin.SoEngine_initClasses()

def SoEngine_getClassTypeId():
  """SoEngine_getClassTypeId() -> SoType"""
  return _coin.SoEngine_getClassTypeId()

def SoEngine_getByName(*args):
  """
    getByName(SbName name) -> SoEngine
    SoEngine_getByName(SbName name, SoEngineList el) -> int
    """
  return _coin.SoEngine_getByName(*args)

class SoEngineOutput(object):
    """Proxy of C++ SoEngineOutput class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoEngineOutput"""
        this = _coin.new_SoEngineOutput()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoEngineOutput
    __del__ = lambda self : None;
    def getConnectionType(self):
        """getConnectionType(self) -> SoType"""
        return _coin.SoEngineOutput_getConnectionType(self)

    def getForwardConnections(self, *args):
        """getForwardConnections(self, SoFieldList fl) -> int"""
        return _coin.SoEngineOutput_getForwardConnections(self, *args)

    def enable(self, *args):
        """enable(self, SbBool flag)"""
        return _coin.SoEngineOutput_enable(self, *args)

    def isEnabled(self):
        """isEnabled(self) -> SbBool"""
        return _coin.SoEngineOutput_isEnabled(self)

    def getContainer(self):
        """getContainer(self) -> SoEngine"""
        return _coin.SoEngineOutput_getContainer(self)

    def getNodeContainer(self):
        """getNodeContainer(self) -> SoNodeEngine"""
        return _coin.SoEngineOutput_getNodeContainer(self)

    def isNodeEngineOutput(self):
        """isNodeEngineOutput(self) -> SbBool"""
        return _coin.SoEngineOutput_isNodeEngineOutput(self)

    def setContainer(self, *args):
        """setContainer(self, SoEngine engine)"""
        return _coin.SoEngineOutput_setContainer(self, *args)

    def setNodeContainer(self, *args):
        """setNodeContainer(self, SoNodeEngine nodeengine)"""
        return _coin.SoEngineOutput_setNodeContainer(self, *args)

    def addConnection(self, *args):
        """addConnection(self, SoField f)"""
        return _coin.SoEngineOutput_addConnection(self, *args)

    def removeConnection(self, *args):
        """removeConnection(self, SoField f)"""
        return _coin.SoEngineOutput_removeConnection(self, *args)

    def getNumConnections(self):
        """getNumConnections(self) -> int"""
        return _coin.SoEngineOutput_getNumConnections(self)

    def prepareToWrite(self):
        """prepareToWrite(self)"""
        return _coin.SoEngineOutput_prepareToWrite(self)

    def doneWriting(self):
        """doneWriting(self)"""
        return _coin.SoEngineOutput_doneWriting(self)

    def touchSlaves(self, *args):
        """touchSlaves(self, SoNotList nl, SbBool donotify)"""
        return _coin.SoEngineOutput_touchSlaves(self, *args)

    def getFieldContainer(self):
        """getFieldContainer(self) -> SoFieldContainer"""
        return _coin.SoEngineOutput_getFieldContainer(self)

SoEngineOutput_swigregister = _coin.SoEngineOutput_swigregister
SoEngineOutput_swigregister(SoEngineOutput)

class SoEngineOutputData(object):
    """Proxy of C++ SoEngineOutputData class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SoEngineOutputData
        __init__(self, SoEngineOutputData data) -> SoEngineOutputData
        __init__(self, int approxnum) -> SoEngineOutputData
        """
        this = _coin.new_SoEngineOutputData(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoEngineOutputData
    __del__ = lambda self : None;
    def addOutput(self, *args):
        """
        addOutput(self, SoEngine base, char name, SoEngineOutput output, SoType type)
        addOutput(self, SoNodeEngine base, char name, SoEngineOutput output, 
            SoType type)
        """
        return _coin.SoEngineOutputData_addOutput(self, *args)

    def getNumOutputs(self):
        """getNumOutputs(self) -> int"""
        return _coin.SoEngineOutputData_getNumOutputs(self)

    def getOutputName(self, *args):
        """getOutputName(self, int index) -> SbName"""
        return _coin.SoEngineOutputData_getOutputName(self, *args)

    def getOutput(self, *args):
        """
        getOutput(self, SoEngine engine, int index) -> SoEngineOutput
        getOutput(self, SoNodeEngine engine, int index) -> SoEngineOutput
        """
        return _coin.SoEngineOutputData_getOutput(self, *args)

    def getIndex(self, *args):
        """
        getIndex(self, SoEngine engine, SoEngineOutput output) -> int
        getIndex(self, SoNodeEngine engine, SoEngineOutput output) -> int
        """
        return _coin.SoEngineOutputData_getIndex(self, *args)

    def getType(self, *args):
        """getType(self, int index) -> SoType"""
        return _coin.SoEngineOutputData_getType(self, *args)

    def readDescriptions(self, *args):
        """readDescriptions(self, SoInput input, SoEngine engine) -> SbBool"""
        return _coin.SoEngineOutputData_readDescriptions(self, *args)

    def writeDescriptions(self, *args):
        """writeDescriptions(self, SoOutput out, SoEngine engine)"""
        return _coin.SoEngineOutputData_writeDescriptions(self, *args)

SoEngineOutputData_swigregister = _coin.SoEngineOutputData_swigregister
SoEngineOutputData_swigregister(SoEngineOutputData)

class SoMFBool(SoMField):
    """Proxy of C++ SoMFBool class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFBool"""
        this = _coin.new_SoMFBool()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFBool
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFBool_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFBool_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFBool_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFBool_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFBool_isSame(self, *args)

    def find(self, *args):
        """
        find(self, SbBool value, SbBool addifnotfound = 0) -> int
        find(self, SbBool value) -> int
        """
        return _coin.SoMFBool_find(self, *args)

    def setValues(*args):
       if len(args) == 2:
          if isinstance(args[1], SoMFBool):
             val = args[1].getValues()
             return _coin.SoMFBool_setValues(args[0],0,len(val),val)
          else:
             return _coin.SoMFBool_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          if isinstance(args[2], SoMFBool):
             val = args[2].getValues()
             return _coin.SoMFBool_setValues(args[0],args[1],len(val),val)
          else:
             return _coin.SoMFBool_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFBool_setValues(*args)


    def set1Value(self, *args):
        """set1Value(self, int idx, SbBool value)"""
        return _coin.SoMFBool_set1Value(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFBool field) -> SbBool"""
        return _coin.SoMFBool___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFBool field) -> SbBool"""
        return _coin.SoMFBool___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SbBool"""
        return _coin.SoMFBool_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFBool_finishEditing(self)

    def setValuesPointer(self, *args):
        """
        setValuesPointer(self, int num, SbBool userdata)
        setValuesPointer(self, int num, SbBool userdata)
        """
        return _coin.SoMFBool_setValuesPointer(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMFBool_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbBool value)
        setValue(self, SoMFBool other)
        """
        return _coin.SoMFBool_setValue(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> SbBool"""
        return _coin.SoMFBool___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, SbBool value)"""
        return _coin.SoMFBool___setitem__(self, *args)

    def getValues(self, i = 0):
        """
        getValues(self, int i = 0) -> SbBool
        getValues(self) -> SbBool
        """
        return _coin.SoMFBool_getValues(self, i)

SoMFBool_swigregister = _coin.SoMFBool_swigregister
SoMFBool_swigregister(SoMFBool)

def SoMFBool_createInstance():
  """SoMFBool_createInstance() -> void"""
  return _coin.SoMFBool_createInstance()

def SoMFBool_getClassTypeId():
  """SoMFBool_getClassTypeId() -> SoType"""
  return _coin.SoMFBool_getClassTypeId()

def SoMFBool_initClass():
  """SoMFBool_initClass()"""
  return _coin.SoMFBool_initClass()

class SoMFEnum(SoMField):
    """Proxy of C++ SoMFEnum class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFEnum"""
        this = _coin.new_SoMFEnum()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFEnum
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFEnum_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFEnum_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFEnum_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFEnum_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFEnum_isSame(self, *args)

    def find(self, *args):
        """
        find(self, int value, SbBool addifnotfound = 0) -> int
        find(self, int value) -> int
        """
        return _coin.SoMFEnum_find(self, *args)

    def setValues(*args):
       if len(args) == 2:
          if isinstance(args[1], SoMFEnum):
             val = args[1].getValues()
             return _coin.SoMFEnum_setValues(args[0],0,len(val),val)
          else:
             return _coin.SoMFEnum_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          if isinstance(args[2], SoMFEnum):
             val = args[2].getValues()
             return _coin.SoMFEnum_setValues(args[0],args[1],len(val),val)
          else:
             return _coin.SoMFEnum_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFEnum_setValues(*args)


    def __eq__(self, *args):
        """__eq__(self, SoMFEnum field) -> SbBool"""
        return _coin.SoMFEnum___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFEnum field) -> SbBool"""
        return _coin.SoMFEnum___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> int"""
        return _coin.SoMFEnum_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFEnum_finishEditing(self)

    def initClass():
        """initClass()"""
        return _coin.SoMFEnum_initClass()

    initClass = staticmethod(initClass)
    def set1Value(self, *args):
        """
        set1Value(self, int idx, int value)
        set1Value(self, int idx, SbName name)
        """
        return _coin.SoMFEnum_set1Value(self, *args)

    def setEnums(self, *args):
        """setEnums(self, int num, int values, SbName names)"""
        return _coin.SoMFEnum_setEnums(self, *args)

    def getNumEnums(self):
        """getNumEnums(self) -> int"""
        return _coin.SoMFEnum_getNumEnums(self)

    def getEnum(self, *args):
        """getEnum(self, int idx, SbName name) -> int"""
        return _coin.SoMFEnum_getEnum(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> int"""
        return _coin.SoMFEnum___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, int value)"""
        return _coin.SoMFEnum___setitem__(self, *args)

    def setValue(self, *args):
        """
        setValue(self, int value)
        setValue(self, SbName name)
        setValue(self, SoMFEnum other)
        """
        return _coin.SoMFEnum_setValue(self, *args)

    def getValues(self, i = 0):
        """
        getValues(self, int i = 0) -> int
        getValues(self) -> int
        """
        return _coin.SoMFEnum_getValues(self, i)

SoMFEnum_swigregister = _coin.SoMFEnum_swigregister
SoMFEnum_swigregister(SoMFEnum)

def SoMFEnum_createInstance():
  """SoMFEnum_createInstance() -> void"""
  return _coin.SoMFEnum_createInstance()

def SoMFEnum_getClassTypeId():
  """SoMFEnum_getClassTypeId() -> SoType"""
  return _coin.SoMFEnum_getClassTypeId()

def SoMFEnum_initClass():
  """SoMFEnum_initClass()"""
  return _coin.SoMFEnum_initClass()

class SoBoolOperation(SoEngine):
    """Proxy of C++ SoBoolOperation class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoBoolOperation_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoBoolOperation_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoBoolOperation_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoBoolOperation_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoBoolOperation_createInstance()

    createInstance = staticmethod(createInstance)
    CLEAR = _coin.SoBoolOperation_CLEAR
    SET = _coin.SoBoolOperation_SET
    A = _coin.SoBoolOperation_A
    NOT_A = _coin.SoBoolOperation_NOT_A
    B = _coin.SoBoolOperation_B
    NOT_B = _coin.SoBoolOperation_NOT_B
    A_OR_B = _coin.SoBoolOperation_A_OR_B
    NOT_A_OR_B = _coin.SoBoolOperation_NOT_A_OR_B
    A_OR_NOT_B = _coin.SoBoolOperation_A_OR_NOT_B
    NOT_A_OR_NOT_B = _coin.SoBoolOperation_NOT_A_OR_NOT_B
    A_AND_B = _coin.SoBoolOperation_A_AND_B
    NOT_A_AND_B = _coin.SoBoolOperation_NOT_A_AND_B
    A_AND_NOT_B = _coin.SoBoolOperation_A_AND_NOT_B
    NOT_A_AND_NOT_B = _coin.SoBoolOperation_NOT_A_AND_NOT_B
    A_EQUALS_B = _coin.SoBoolOperation_A_EQUALS_B
    A_NOT_EQUALS_B = _coin.SoBoolOperation_A_NOT_EQUALS_B
    a = _swig_property(_coin.SoBoolOperation_a_get, _coin.SoBoolOperation_a_set)
    b = _swig_property(_coin.SoBoolOperation_b_get, _coin.SoBoolOperation_b_set)
    operation = _swig_property(_coin.SoBoolOperation_operation_get, _coin.SoBoolOperation_operation_set)
    output = _swig_property(_coin.SoBoolOperation_output_get, _coin.SoBoolOperation_output_set)
    inverse = _swig_property(_coin.SoBoolOperation_inverse_get, _coin.SoBoolOperation_inverse_set)
    def __init__(self): 
        """__init__(self) -> SoBoolOperation"""
        this = _coin.new_SoBoolOperation()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoBoolOperation_initClass()

    initClass = staticmethod(initClass)
SoBoolOperation_swigregister = _coin.SoBoolOperation_swigregister
SoBoolOperation_swigregister(SoBoolOperation)

def SoBoolOperation_getClassTypeId():
  """SoBoolOperation_getClassTypeId() -> SoType"""
  return _coin.SoBoolOperation_getClassTypeId()

def SoBoolOperation_createInstance():
  """SoBoolOperation_createInstance() -> void"""
  return _coin.SoBoolOperation_createInstance()

def SoBoolOperation_initClass():
  """SoBoolOperation_initClass()"""
  return _coin.SoBoolOperation_initClass()

class SoMFFloat(SoMField):
    """Proxy of C++ SoMFFloat class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFFloat"""
        this = _coin.new_SoMFFloat()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFFloat
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFFloat_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFFloat_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFFloat_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFFloat_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFFloat_isSame(self, *args)

    def find(self, *args):
        """
        find(self, float value, SbBool addifnotfound = 0) -> int
        find(self, float value) -> int
        """
        return _coin.SoMFFloat_find(self, *args)

    def setValues(*args):
       if len(args) == 2:
          if isinstance(args[1], SoMFFloat):
             val = args[1].getValues()
             return _coin.SoMFFloat_setValues(args[0],0,len(val),val)
          else:
             return _coin.SoMFFloat_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          if isinstance(args[2], SoMFFloat):
             val = args[2].getValues()
             return _coin.SoMFFloat_setValues(args[0],args[1],len(val),val)
          else:
             return _coin.SoMFFloat_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFFloat_setValues(*args)


    def set1Value(self, *args):
        """set1Value(self, int idx, float value)"""
        return _coin.SoMFFloat_set1Value(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFFloat field) -> SbBool"""
        return _coin.SoMFFloat___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFFloat field) -> SbBool"""
        return _coin.SoMFFloat___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> float"""
        return _coin.SoMFFloat_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFFloat_finishEditing(self)

    def setValuesPointer(self, *args):
        """
        setValuesPointer(self, int num, float userdata)
        setValuesPointer(self, int num, float userdata)
        """
        return _coin.SoMFFloat_setValuesPointer(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMFFloat_initClass()

    initClass = staticmethod(initClass)
    def __getitem__(self, *args):
        """__getitem__(self, int i) -> float"""
        return _coin.SoMFFloat___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, float value)"""
        return _coin.SoMFFloat___setitem__(self, *args)

    def setValue(self, *args):
        """
        setValue(self, float value)
        setValue(self, SoMFFloat other)
        """
        return _coin.SoMFFloat_setValue(self, *args)

    def getValues(self, i = 0):
        """
        getValues(self, int i = 0) -> float
        getValues(self) -> float
        """
        return _coin.SoMFFloat_getValues(self, i)

SoMFFloat_swigregister = _coin.SoMFFloat_swigregister
SoMFFloat_swigregister(SoMFFloat)

def SoMFFloat_createInstance():
  """SoMFFloat_createInstance() -> void"""
  return _coin.SoMFFloat_createInstance()

def SoMFFloat_getClassTypeId():
  """SoMFFloat_getClassTypeId() -> SoType"""
  return _coin.SoMFFloat_getClassTypeId()

def SoMFFloat_initClass():
  """SoMFFloat_initClass()"""
  return _coin.SoMFFloat_initClass()

class SoMFVec3f(SoMField):
    """Proxy of C++ SoMFVec3f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFVec3f"""
        this = _coin.new_SoMFVec3f()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFVec3f
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFVec3f_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFVec3f_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFVec3f_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFVec3f_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFVec3f_isSame(self, *args)

    def find(self, *args):
        """
        find(self, SbVec3f value, SbBool addifnotfound = 0) -> int
        find(self, SbVec3f value) -> int
        """
        return _coin.SoMFVec3f_find(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFVec3f field) -> SbBool"""
        return _coin.SoMFVec3f___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFVec3f field) -> SbBool"""
        return _coin.SoMFVec3f___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SbVec3f"""
        return _coin.SoMFVec3f_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFVec3f_finishEditing(self)

    def setValuesPointer(self, *args):
        """
        setValuesPointer(self, int num, SbVec3f userdata)
        setValuesPointer(self, int num, SbVec3f userdata)
        setValuesPointer(self, int num, float userdata)
        setValuesPointer(self, int num, float userdata)
        """
        return _coin.SoMFVec3f_setValuesPointer(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMFVec3f_initClass()

    initClass = staticmethod(initClass)
    def setValues(*args):
       if len(args) == 2:
          return _coin.SoMFVec3f_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          return _coin.SoMFVec3f_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFVec3f_setValues(*args)


    def set1Value(self, *args):
        """
        set1Value(self, int idx, SbVec3f value)
        set1Value(self, int idx, float x, float y, float z)
        set1Value(self, int idx, float xyz)
        """
        return _coin.SoMFVec3f_set1Value(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> SbVec3f"""
        return _coin.SoMFVec3f___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, SbVec3f value)"""
        return _coin.SoMFVec3f___setitem__(self, *args)

    def setValue(self, *args):
        """
        setValue(self, SbVec3f value)
        setValue(self, float x, float y, float z)
        setValue(self, float xyz)
        setValue(self, SoMFVec3f other)
        """
        return _coin.SoMFVec3f_setValue(self, *args)

    def getValues(self, i = 0):
        """
        getValues(self, int i = 0) -> SbVec3f
        getValues(self) -> SbVec3f
        """
        return _coin.SoMFVec3f_getValues(self, i)

SoMFVec3f_swigregister = _coin.SoMFVec3f_swigregister
SoMFVec3f_swigregister(SoMFVec3f)

def SoMFVec3f_createInstance():
  """SoMFVec3f_createInstance() -> void"""
  return _coin.SoMFVec3f_createInstance()

def SoMFVec3f_getClassTypeId():
  """SoMFVec3f_getClassTypeId() -> SoType"""
  return _coin.SoMFVec3f_getClassTypeId()

def SoMFVec3f_initClass():
  """SoMFVec3f_initClass()"""
  return _coin.SoMFVec3f_initClass()

class SoMFString(SoMField):
    """Proxy of C++ SoMFString class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFString"""
        this = _coin.new_SoMFString()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFString
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFString_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFString_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFString_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFString_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFString_isSame(self, *args)

    def find(self, *args):
        """
        find(self, SbString value, SbBool addifnotfound = 0) -> int
        find(self, SbString value) -> int
        """
        return _coin.SoMFString_find(self, *args)

    def set1Value(self, *args):
        """set1Value(self, int idx, SbString value)"""
        return _coin.SoMFString_set1Value(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFString field) -> SbBool"""
        return _coin.SoMFString___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFString field) -> SbBool"""
        return _coin.SoMFString___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SbString"""
        return _coin.SoMFString_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFString_finishEditing(self)

    def initClass():
        """initClass()"""
        return _coin.SoMFString_initClass()

    initClass = staticmethod(initClass)
    def setValues(*args):
       if len(args) == 2:
         return _coin.SoMFString_setValues(args[0], 0, len(args[1]), args[1])
       elif len(args) == 3:
         return _coin.SoMFString_setValues(args[0], args[1], len(args[2]), args[2])
       return _coin.SoMFString_setValues(*args)


    def deleteText(self, *args):
        """deleteText(self, int fromline, int fromchar, int toline, int tochar)"""
        return _coin.SoMFString_deleteText(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> SbString"""
        return _coin.SoMFString___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, SbString value)"""
        return _coin.SoMFString___setitem__(self, *args)

    def setValue(self, *args):
        """
        setValue(self, SbString value)
        setValue(self, char string)
        setValue(self, SoMFString other)
        """
        return _coin.SoMFString_setValue(self, *args)

    def getValues(self, i = 0):
        """
        getValues(self, int i = 0) -> SbString
        getValues(self) -> SbString
        """
        return _coin.SoMFString_getValues(self, i)

SoMFString_swigregister = _coin.SoMFString_swigregister
SoMFString_swigregister(SoMFString)

def SoMFString_createInstance():
  """SoMFString_createInstance() -> void"""
  return _coin.SoMFString_createInstance()

def SoMFString_getClassTypeId():
  """SoMFString_getClassTypeId() -> SoType"""
  return _coin.SoMFString_getClassTypeId()

def SoMFString_initClass():
  """SoMFString_initClass()"""
  return _coin.SoMFString_initClass()

class SoCalculator(SoEngine):
    """Proxy of C++ SoCalculator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoCalculator_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoCalculator_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoCalculator_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoCalculator_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoCalculator_createInstance()

    createInstance = staticmethod(createInstance)
    a = _swig_property(_coin.SoCalculator_a_get, _coin.SoCalculator_a_set)
    b = _swig_property(_coin.SoCalculator_b_get, _coin.SoCalculator_b_set)
    c = _swig_property(_coin.SoCalculator_c_get, _coin.SoCalculator_c_set)
    d = _swig_property(_coin.SoCalculator_d_get, _coin.SoCalculator_d_set)
    e = _swig_property(_coin.SoCalculator_e_get, _coin.SoCalculator_e_set)
    f = _swig_property(_coin.SoCalculator_f_get, _coin.SoCalculator_f_set)
    g = _swig_property(_coin.SoCalculator_g_get, _coin.SoCalculator_g_set)
    h = _swig_property(_coin.SoCalculator_h_get, _coin.SoCalculator_h_set)
    A = _swig_property(_coin.SoCalculator_A_get, _coin.SoCalculator_A_set)
    B = _swig_property(_coin.SoCalculator_B_get, _coin.SoCalculator_B_set)
    C = _swig_property(_coin.SoCalculator_C_get, _coin.SoCalculator_C_set)
    D = _swig_property(_coin.SoCalculator_D_get, _coin.SoCalculator_D_set)
    E = _swig_property(_coin.SoCalculator_E_get, _coin.SoCalculator_E_set)
    F = _swig_property(_coin.SoCalculator_F_get, _coin.SoCalculator_F_set)
    G = _swig_property(_coin.SoCalculator_G_get, _coin.SoCalculator_G_set)
    H = _swig_property(_coin.SoCalculator_H_get, _coin.SoCalculator_H_set)
    expression = _swig_property(_coin.SoCalculator_expression_get, _coin.SoCalculator_expression_set)
    oa = _swig_property(_coin.SoCalculator_oa_get, _coin.SoCalculator_oa_set)
    ob = _swig_property(_coin.SoCalculator_ob_get, _coin.SoCalculator_ob_set)
    oc = _swig_property(_coin.SoCalculator_oc_get, _coin.SoCalculator_oc_set)
    od = _swig_property(_coin.SoCalculator_od_get, _coin.SoCalculator_od_set)
    oA = _swig_property(_coin.SoCalculator_oA_get, _coin.SoCalculator_oA_set)
    oB = _swig_property(_coin.SoCalculator_oB_get, _coin.SoCalculator_oB_set)
    oC = _swig_property(_coin.SoCalculator_oC_get, _coin.SoCalculator_oC_set)
    oD = _swig_property(_coin.SoCalculator_oD_get, _coin.SoCalculator_oD_set)
    def __init__(self): 
        """__init__(self) -> SoCalculator"""
        this = _coin.new_SoCalculator()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoCalculator_initClass()

    initClass = staticmethod(initClass)
SoCalculator_swigregister = _coin.SoCalculator_swigregister
SoCalculator_swigregister(SoCalculator)

def SoCalculator_getClassTypeId():
  """SoCalculator_getClassTypeId() -> SoType"""
  return _coin.SoCalculator_getClassTypeId()

def SoCalculator_createInstance():
  """SoCalculator_createInstance() -> void"""
  return _coin.SoCalculator_createInstance()

def SoCalculator_initClass():
  """SoCalculator_initClass()"""
  return _coin.SoCalculator_initClass()

class SoMFVec2f(SoMField):
    """Proxy of C++ SoMFVec2f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFVec2f"""
        this = _coin.new_SoMFVec2f()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFVec2f
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFVec2f_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFVec2f_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFVec2f_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFVec2f_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFVec2f_isSame(self, *args)

    def find(self, *args):
        """
        find(self, SbVec2f value, SbBool addifnotfound = 0) -> int
        find(self, SbVec2f value) -> int
        """
        return _coin.SoMFVec2f_find(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFVec2f field) -> SbBool"""
        return _coin.SoMFVec2f___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFVec2f field) -> SbBool"""
        return _coin.SoMFVec2f___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SbVec2f"""
        return _coin.SoMFVec2f_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFVec2f_finishEditing(self)

    def setValuesPointer(self, *args):
        """
        setValuesPointer(self, int num, SbVec2f userdata)
        setValuesPointer(self, int num, SbVec2f userdata)
        setValuesPointer(self, int num, float userdata)
        setValuesPointer(self, int num, float userdata)
        """
        return _coin.SoMFVec2f_setValuesPointer(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMFVec2f_initClass()

    initClass = staticmethod(initClass)
    def setValues(*args):
       if len(args) == 2:
          return _coin.SoMFVec2f_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          return _coin.SoMFVec2f_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFVec2f_setValues(*args)


    def set1Value(self, *args):
        """
        set1Value(self, int idx, SbVec2f value)
        set1Value(self, int idx, float x, float y)
        set1Value(self, int idx, float xy)
        """
        return _coin.SoMFVec2f_set1Value(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> SbVec2f"""
        return _coin.SoMFVec2f___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, SbVec2f value)"""
        return _coin.SoMFVec2f___setitem__(self, *args)

    def setValue(self, *args):
        """
        setValue(self, SbVec2f value)
        setValue(self, float x, float y)
        setValue(self, float xy)
        setValue(self, SoMFVec2f other)
        """
        return _coin.SoMFVec2f_setValue(self, *args)

    def getValues(self, i = 0):
        """
        getValues(self, int i = 0) -> SbVec2f
        getValues(self) -> SbVec2f
        """
        return _coin.SoMFVec2f_getValues(self, i)

SoMFVec2f_swigregister = _coin.SoMFVec2f_swigregister
SoMFVec2f_swigregister(SoMFVec2f)

def SoMFVec2f_createInstance():
  """SoMFVec2f_createInstance() -> void"""
  return _coin.SoMFVec2f_createInstance()

def SoMFVec2f_getClassTypeId():
  """SoMFVec2f_getClassTypeId() -> SoType"""
  return _coin.SoMFVec2f_getClassTypeId()

def SoMFVec2f_initClass():
  """SoMFVec2f_initClass()"""
  return _coin.SoMFVec2f_initClass()

class SoComposeVec2f(SoEngine):
    """Proxy of C++ SoComposeVec2f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoComposeVec2f_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoComposeVec2f_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoComposeVec2f_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoComposeVec2f_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoComposeVec2f_createInstance()

    createInstance = staticmethod(createInstance)
    def __init__(self): 
        """__init__(self) -> SoComposeVec2f"""
        this = _coin.new_SoComposeVec2f()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoComposeVec2f_initClass()

    initClass = staticmethod(initClass)
    x = _swig_property(_coin.SoComposeVec2f_x_get, _coin.SoComposeVec2f_x_set)
    y = _swig_property(_coin.SoComposeVec2f_y_get, _coin.SoComposeVec2f_y_set)
    vector = _swig_property(_coin.SoComposeVec2f_vector_get, _coin.SoComposeVec2f_vector_set)
SoComposeVec2f_swigregister = _coin.SoComposeVec2f_swigregister
SoComposeVec2f_swigregister(SoComposeVec2f)

def SoComposeVec2f_getClassTypeId():
  """SoComposeVec2f_getClassTypeId() -> SoType"""
  return _coin.SoComposeVec2f_getClassTypeId()

def SoComposeVec2f_createInstance():
  """SoComposeVec2f_createInstance() -> void"""
  return _coin.SoComposeVec2f_createInstance()

def SoComposeVec2f_initClass():
  """SoComposeVec2f_initClass()"""
  return _coin.SoComposeVec2f_initClass()

class SoComposeVec3f(SoEngine):
    """Proxy of C++ SoComposeVec3f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoComposeVec3f_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoComposeVec3f_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoComposeVec3f_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoComposeVec3f_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoComposeVec3f_createInstance()

    createInstance = staticmethod(createInstance)
    def __init__(self): 
        """__init__(self) -> SoComposeVec3f"""
        this = _coin.new_SoComposeVec3f()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoComposeVec3f_initClass()

    initClass = staticmethod(initClass)
    x = _swig_property(_coin.SoComposeVec3f_x_get, _coin.SoComposeVec3f_x_set)
    y = _swig_property(_coin.SoComposeVec3f_y_get, _coin.SoComposeVec3f_y_set)
    z = _swig_property(_coin.SoComposeVec3f_z_get, _coin.SoComposeVec3f_z_set)
    vector = _swig_property(_coin.SoComposeVec3f_vector_get, _coin.SoComposeVec3f_vector_set)
SoComposeVec3f_swigregister = _coin.SoComposeVec3f_swigregister
SoComposeVec3f_swigregister(SoComposeVec3f)

def SoComposeVec3f_getClassTypeId():
  """SoComposeVec3f_getClassTypeId() -> SoType"""
  return _coin.SoComposeVec3f_getClassTypeId()

def SoComposeVec3f_createInstance():
  """SoComposeVec3f_createInstance() -> void"""
  return _coin.SoComposeVec3f_createInstance()

def SoComposeVec3f_initClass():
  """SoComposeVec3f_initClass()"""
  return _coin.SoComposeVec3f_initClass()

class SoMFVec4f(SoMField):
    """Proxy of C++ SoMFVec4f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFVec4f"""
        this = _coin.new_SoMFVec4f()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFVec4f
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFVec4f_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFVec4f_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFVec4f_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFVec4f_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFVec4f_isSame(self, *args)

    def find(self, *args):
        """
        find(self, SbVec4f value, SbBool addifnotfound = 0) -> int
        find(self, SbVec4f value) -> int
        """
        return _coin.SoMFVec4f_find(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFVec4f field) -> SbBool"""
        return _coin.SoMFVec4f___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFVec4f field) -> SbBool"""
        return _coin.SoMFVec4f___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SbVec4f"""
        return _coin.SoMFVec4f_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFVec4f_finishEditing(self)

    def setValuesPointer(self, *args):
        """
        setValuesPointer(self, int num, SbVec4f userdata)
        setValuesPointer(self, int num, SbVec4f userdata)
        setValuesPointer(self, int num, float userdata)
        setValuesPointer(self, int num, float userdata)
        """
        return _coin.SoMFVec4f_setValuesPointer(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMFVec4f_initClass()

    initClass = staticmethod(initClass)
    def setValues(*args):
       if len(args) == 2:
          return _coin.SoMFVec4f_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          return _coin.SoMFVec4f_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFVec4f_setValues(*args)


    def set1Value(self, *args):
        """
        set1Value(self, int idx, SbVec4f value)
        set1Value(self, int idx, float x, float y, float z, float w)
        set1Value(self, int idx, float xyzw)
        """
        return _coin.SoMFVec4f_set1Value(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> SbVec4f"""
        return _coin.SoMFVec4f___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, SbVec4f value)"""
        return _coin.SoMFVec4f___setitem__(self, *args)

    def setValue(self, *args):
        """
        setValue(self, SbVec4f value)
        setValue(self, float x, float y, float z, float w)
        setValue(self, float xyzw)
        setValue(self, SoMFVec4f other)
        """
        return _coin.SoMFVec4f_setValue(self, *args)

    def getValues(self, i = 0):
        """
        getValues(self, int i = 0) -> SbVec4f
        getValues(self) -> SbVec4f
        """
        return _coin.SoMFVec4f_getValues(self, i)

SoMFVec4f_swigregister = _coin.SoMFVec4f_swigregister
SoMFVec4f_swigregister(SoMFVec4f)

def SoMFVec4f_createInstance():
  """SoMFVec4f_createInstance() -> void"""
  return _coin.SoMFVec4f_createInstance()

def SoMFVec4f_getClassTypeId():
  """SoMFVec4f_getClassTypeId() -> SoType"""
  return _coin.SoMFVec4f_getClassTypeId()

def SoMFVec4f_initClass():
  """SoMFVec4f_initClass()"""
  return _coin.SoMFVec4f_initClass()

class SoComposeVec4f(SoEngine):
    """Proxy of C++ SoComposeVec4f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoComposeVec4f_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoComposeVec4f_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoComposeVec4f_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoComposeVec4f_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoComposeVec4f_createInstance()

    createInstance = staticmethod(createInstance)
    def __init__(self): 
        """__init__(self) -> SoComposeVec4f"""
        this = _coin.new_SoComposeVec4f()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoComposeVec4f_initClass()

    initClass = staticmethod(initClass)
    x = _swig_property(_coin.SoComposeVec4f_x_get, _coin.SoComposeVec4f_x_set)
    y = _swig_property(_coin.SoComposeVec4f_y_get, _coin.SoComposeVec4f_y_set)
    z = _swig_property(_coin.SoComposeVec4f_z_get, _coin.SoComposeVec4f_z_set)
    w = _swig_property(_coin.SoComposeVec4f_w_get, _coin.SoComposeVec4f_w_set)
    vector = _swig_property(_coin.SoComposeVec4f_vector_get, _coin.SoComposeVec4f_vector_set)
SoComposeVec4f_swigregister = _coin.SoComposeVec4f_swigregister
SoComposeVec4f_swigregister(SoComposeVec4f)

def SoComposeVec4f_getClassTypeId():
  """SoComposeVec4f_getClassTypeId() -> SoType"""
  return _coin.SoComposeVec4f_getClassTypeId()

def SoComposeVec4f_createInstance():
  """SoComposeVec4f_createInstance() -> void"""
  return _coin.SoComposeVec4f_createInstance()

def SoComposeVec4f_initClass():
  """SoComposeVec4f_initClass()"""
  return _coin.SoComposeVec4f_initClass()

class SoDecomposeVec2f(SoEngine):
    """Proxy of C++ SoDecomposeVec2f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoDecomposeVec2f_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoDecomposeVec2f_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoDecomposeVec2f_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoDecomposeVec2f_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoDecomposeVec2f_createInstance()

    createInstance = staticmethod(createInstance)
    def __init__(self): 
        """__init__(self) -> SoDecomposeVec2f"""
        this = _coin.new_SoDecomposeVec2f()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoDecomposeVec2f_initClass()

    initClass = staticmethod(initClass)
    vector = _swig_property(_coin.SoDecomposeVec2f_vector_get, _coin.SoDecomposeVec2f_vector_set)
    x = _swig_property(_coin.SoDecomposeVec2f_x_get, _coin.SoDecomposeVec2f_x_set)
    y = _swig_property(_coin.SoDecomposeVec2f_y_get, _coin.SoDecomposeVec2f_y_set)
SoDecomposeVec2f_swigregister = _coin.SoDecomposeVec2f_swigregister
SoDecomposeVec2f_swigregister(SoDecomposeVec2f)

def SoDecomposeVec2f_getClassTypeId():
  """SoDecomposeVec2f_getClassTypeId() -> SoType"""
  return _coin.SoDecomposeVec2f_getClassTypeId()

def SoDecomposeVec2f_createInstance():
  """SoDecomposeVec2f_createInstance() -> void"""
  return _coin.SoDecomposeVec2f_createInstance()

def SoDecomposeVec2f_initClass():
  """SoDecomposeVec2f_initClass()"""
  return _coin.SoDecomposeVec2f_initClass()

class SoDecomposeVec3f(SoEngine):
    """Proxy of C++ SoDecomposeVec3f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoDecomposeVec3f_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoDecomposeVec3f_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoDecomposeVec3f_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoDecomposeVec3f_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoDecomposeVec3f_createInstance()

    createInstance = staticmethod(createInstance)
    def __init__(self): 
        """__init__(self) -> SoDecomposeVec3f"""
        this = _coin.new_SoDecomposeVec3f()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoDecomposeVec3f_initClass()

    initClass = staticmethod(initClass)
    vector = _swig_property(_coin.SoDecomposeVec3f_vector_get, _coin.SoDecomposeVec3f_vector_set)
    x = _swig_property(_coin.SoDecomposeVec3f_x_get, _coin.SoDecomposeVec3f_x_set)
    y = _swig_property(_coin.SoDecomposeVec3f_y_get, _coin.SoDecomposeVec3f_y_set)
    z = _swig_property(_coin.SoDecomposeVec3f_z_get, _coin.SoDecomposeVec3f_z_set)
SoDecomposeVec3f_swigregister = _coin.SoDecomposeVec3f_swigregister
SoDecomposeVec3f_swigregister(SoDecomposeVec3f)

def SoDecomposeVec3f_getClassTypeId():
  """SoDecomposeVec3f_getClassTypeId() -> SoType"""
  return _coin.SoDecomposeVec3f_getClassTypeId()

def SoDecomposeVec3f_createInstance():
  """SoDecomposeVec3f_createInstance() -> void"""
  return _coin.SoDecomposeVec3f_createInstance()

def SoDecomposeVec3f_initClass():
  """SoDecomposeVec3f_initClass()"""
  return _coin.SoDecomposeVec3f_initClass()

class SoDecomposeVec4f(SoEngine):
    """Proxy of C++ SoDecomposeVec4f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoDecomposeVec4f_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoDecomposeVec4f_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoDecomposeVec4f_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoDecomposeVec4f_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoDecomposeVec4f_createInstance()

    createInstance = staticmethod(createInstance)
    def __init__(self): 
        """__init__(self) -> SoDecomposeVec4f"""
        this = _coin.new_SoDecomposeVec4f()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoDecomposeVec4f_initClass()

    initClass = staticmethod(initClass)
    vector = _swig_property(_coin.SoDecomposeVec4f_vector_get, _coin.SoDecomposeVec4f_vector_set)
    x = _swig_property(_coin.SoDecomposeVec4f_x_get, _coin.SoDecomposeVec4f_x_set)
    y = _swig_property(_coin.SoDecomposeVec4f_y_get, _coin.SoDecomposeVec4f_y_set)
    z = _swig_property(_coin.SoDecomposeVec4f_z_get, _coin.SoDecomposeVec4f_z_set)
    w = _swig_property(_coin.SoDecomposeVec4f_w_get, _coin.SoDecomposeVec4f_w_set)
SoDecomposeVec4f_swigregister = _coin.SoDecomposeVec4f_swigregister
SoDecomposeVec4f_swigregister(SoDecomposeVec4f)

def SoDecomposeVec4f_getClassTypeId():
  """SoDecomposeVec4f_getClassTypeId() -> SoType"""
  return _coin.SoDecomposeVec4f_getClassTypeId()

def SoDecomposeVec4f_createInstance():
  """SoDecomposeVec4f_createInstance() -> void"""
  return _coin.SoDecomposeVec4f_createInstance()

def SoDecomposeVec4f_initClass():
  """SoDecomposeVec4f_initClass()"""
  return _coin.SoDecomposeVec4f_initClass()

class SoComposeRotation(SoEngine):
    """Proxy of C++ SoComposeRotation class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoComposeRotation_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoComposeRotation_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoComposeRotation_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoComposeRotation_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoComposeRotation_createInstance()

    createInstance = staticmethod(createInstance)
    def __init__(self): 
        """__init__(self) -> SoComposeRotation"""
        this = _coin.new_SoComposeRotation()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoComposeRotation_initClass()

    initClass = staticmethod(initClass)
    axis = _swig_property(_coin.SoComposeRotation_axis_get, _coin.SoComposeRotation_axis_set)
    angle = _swig_property(_coin.SoComposeRotation_angle_get, _coin.SoComposeRotation_angle_set)
    rotation = _swig_property(_coin.SoComposeRotation_rotation_get, _coin.SoComposeRotation_rotation_set)
SoComposeRotation_swigregister = _coin.SoComposeRotation_swigregister
SoComposeRotation_swigregister(SoComposeRotation)

def SoComposeRotation_getClassTypeId():
  """SoComposeRotation_getClassTypeId() -> SoType"""
  return _coin.SoComposeRotation_getClassTypeId()

def SoComposeRotation_createInstance():
  """SoComposeRotation_createInstance() -> void"""
  return _coin.SoComposeRotation_createInstance()

def SoComposeRotation_initClass():
  """SoComposeRotation_initClass()"""
  return _coin.SoComposeRotation_initClass()

class SoMFRotation(SoMField):
    """Proxy of C++ SoMFRotation class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFRotation"""
        this = _coin.new_SoMFRotation()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFRotation
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFRotation_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFRotation_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFRotation_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFRotation_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFRotation_isSame(self, *args)

    def find(self, *args):
        """
        find(self, SbRotation value, SbBool addifnotfound = 0) -> int
        find(self, SbRotation value) -> int
        """
        return _coin.SoMFRotation_find(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFRotation field) -> SbBool"""
        return _coin.SoMFRotation___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFRotation field) -> SbBool"""
        return _coin.SoMFRotation___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SbRotation"""
        return _coin.SoMFRotation_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFRotation_finishEditing(self)

    def initClass():
        """initClass()"""
        return _coin.SoMFRotation_initClass()

    initClass = staticmethod(initClass)
    def setValues(*args):
       if len(args) == 2:
          return _coin.SoMFRotation_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          return _coin.SoMFRotation_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFRotation_setValues(*args)


    def set1Value(self, *args):
        """
        set1Value(self, int idx, SbRotation value)
        set1Value(self, int idx, float q0, float q1, float q2, float q3)
        set1Value(self, int idx, float q)
        set1Value(self, int idx, SbVec3f axis, float angle)
        """
        return _coin.SoMFRotation_set1Value(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> SbRotation"""
        return _coin.SoMFRotation___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, SbRotation value)"""
        return _coin.SoMFRotation___setitem__(self, *args)

    def getValues(self, i = 0):
        """
        getValues(self, int i = 0) -> SbRotation
        getValues(self) -> SbRotation
        """
        return _coin.SoMFRotation_getValues(self, i)

    def setValue(self, *args):
        """
        setValue(self, SbRotation value)
        setValue(self, float q0, float q1, float q2, float q3)
        setValue(self, float q)
        setValue(self, SbVec3f axis, float angle)
        setValue(self, SoMFRotation other)
        """
        return _coin.SoMFRotation_setValue(self, *args)

SoMFRotation_swigregister = _coin.SoMFRotation_swigregister
SoMFRotation_swigregister(SoMFRotation)

def SoMFRotation_createInstance():
  """SoMFRotation_createInstance() -> void"""
  return _coin.SoMFRotation_createInstance()

def SoMFRotation_getClassTypeId():
  """SoMFRotation_getClassTypeId() -> SoType"""
  return _coin.SoMFRotation_getClassTypeId()

def SoMFRotation_initClass():
  """SoMFRotation_initClass()"""
  return _coin.SoMFRotation_initClass()

class SoDecomposeRotation(SoEngine):
    """Proxy of C++ SoDecomposeRotation class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoDecomposeRotation_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoDecomposeRotation_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoDecomposeRotation_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoDecomposeRotation_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoDecomposeRotation_createInstance()

    createInstance = staticmethod(createInstance)
    def __init__(self): 
        """__init__(self) -> SoDecomposeRotation"""
        this = _coin.new_SoDecomposeRotation()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoDecomposeRotation_initClass()

    initClass = staticmethod(initClass)
    rotation = _swig_property(_coin.SoDecomposeRotation_rotation_get, _coin.SoDecomposeRotation_rotation_set)
    axis = _swig_property(_coin.SoDecomposeRotation_axis_get, _coin.SoDecomposeRotation_axis_set)
    angle = _swig_property(_coin.SoDecomposeRotation_angle_get, _coin.SoDecomposeRotation_angle_set)
SoDecomposeRotation_swigregister = _coin.SoDecomposeRotation_swigregister
SoDecomposeRotation_swigregister(SoDecomposeRotation)

def SoDecomposeRotation_getClassTypeId():
  """SoDecomposeRotation_getClassTypeId() -> SoType"""
  return _coin.SoDecomposeRotation_getClassTypeId()

def SoDecomposeRotation_createInstance():
  """SoDecomposeRotation_createInstance() -> void"""
  return _coin.SoDecomposeRotation_createInstance()

def SoDecomposeRotation_initClass():
  """SoDecomposeRotation_initClass()"""
  return _coin.SoDecomposeRotation_initClass()

class SoComposeMatrix(SoEngine):
    """Proxy of C++ SoComposeMatrix class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoComposeMatrix_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoComposeMatrix_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoComposeMatrix_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoComposeMatrix_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoComposeMatrix_createInstance()

    createInstance = staticmethod(createInstance)
    def __init__(self): 
        """__init__(self) -> SoComposeMatrix"""
        this = _coin.new_SoComposeMatrix()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoComposeMatrix_initClass()

    initClass = staticmethod(initClass)
    translation = _swig_property(_coin.SoComposeMatrix_translation_get, _coin.SoComposeMatrix_translation_set)
    rotation = _swig_property(_coin.SoComposeMatrix_rotation_get, _coin.SoComposeMatrix_rotation_set)
    scaleFactor = _swig_property(_coin.SoComposeMatrix_scaleFactor_get, _coin.SoComposeMatrix_scaleFactor_set)
    scaleOrientation = _swig_property(_coin.SoComposeMatrix_scaleOrientation_get, _coin.SoComposeMatrix_scaleOrientation_set)
    center = _swig_property(_coin.SoComposeMatrix_center_get, _coin.SoComposeMatrix_center_set)
    matrix = _swig_property(_coin.SoComposeMatrix_matrix_get, _coin.SoComposeMatrix_matrix_set)
SoComposeMatrix_swigregister = _coin.SoComposeMatrix_swigregister
SoComposeMatrix_swigregister(SoComposeMatrix)

def SoComposeMatrix_getClassTypeId():
  """SoComposeMatrix_getClassTypeId() -> SoType"""
  return _coin.SoComposeMatrix_getClassTypeId()

def SoComposeMatrix_createInstance():
  """SoComposeMatrix_createInstance() -> void"""
  return _coin.SoComposeMatrix_createInstance()

def SoComposeMatrix_initClass():
  """SoComposeMatrix_initClass()"""
  return _coin.SoComposeMatrix_initClass()

class SoMFMatrix(SoMField):
    """Proxy of C++ SoMFMatrix class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFMatrix"""
        this = _coin.new_SoMFMatrix()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFMatrix
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFMatrix_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFMatrix_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFMatrix_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFMatrix_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFMatrix_isSame(self, *args)

    def find(self, *args):
        """
        find(self, SbMatrix value, SbBool addifnotfound = 0) -> int
        find(self, SbMatrix value) -> int
        """
        return _coin.SoMFMatrix_find(self, *args)

    def setValues(*args):
       if len(args) == 2:
          return _coin.SoMFMatrix_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          return _coin.SoMFMatrix_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFMatrix_setValues(*args)


    def set1Value(self, *args):
        """set1Value(self, int idx, SbMatrix value)"""
        return _coin.SoMFMatrix_set1Value(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFMatrix field) -> SbBool"""
        return _coin.SoMFMatrix___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFMatrix field) -> SbBool"""
        return _coin.SoMFMatrix___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SbMatrix"""
        return _coin.SoMFMatrix_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFMatrix_finishEditing(self)

    def initClass():
        """initClass()"""
        return _coin.SoMFMatrix_initClass()

    initClass = staticmethod(initClass)
    def __getitem__(self, *args):
        """__getitem__(self, int i) -> SbMatrix"""
        return _coin.SoMFMatrix___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, SbMatrix value)"""
        return _coin.SoMFMatrix___setitem__(self, *args)

    def getValues(self, i = 0):
        """
        getValues(self, int i = 0) -> SbMatrix
        getValues(self) -> SbMatrix
        """
        return _coin.SoMFMatrix_getValues(self, i)

    def setValue(self, *args):
        """
        setValue(self, SbMatrix value)
        setValue(self, float a11, float a12, float a13, float a14, float a21, 
            float a22, float a23, float a24, float a31, 
            float a32, float a33, float a34, float a41, 
            float a42, float a43, float a44)
        setValue(self, SoMFMatrix other)
        """
        return _coin.SoMFMatrix_setValue(self, *args)

SoMFMatrix_swigregister = _coin.SoMFMatrix_swigregister
SoMFMatrix_swigregister(SoMFMatrix)

def SoMFMatrix_createInstance():
  """SoMFMatrix_createInstance() -> void"""
  return _coin.SoMFMatrix_createInstance()

def SoMFMatrix_getClassTypeId():
  """SoMFMatrix_getClassTypeId() -> SoType"""
  return _coin.SoMFMatrix_getClassTypeId()

def SoMFMatrix_initClass():
  """SoMFMatrix_initClass()"""
  return _coin.SoMFMatrix_initClass()

class SoDecomposeMatrix(SoEngine):
    """Proxy of C++ SoDecomposeMatrix class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoDecomposeMatrix_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoDecomposeMatrix_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoDecomposeMatrix_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoDecomposeMatrix_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoDecomposeMatrix_createInstance()

    createInstance = staticmethod(createInstance)
    def __init__(self): 
        """__init__(self) -> SoDecomposeMatrix"""
        this = _coin.new_SoDecomposeMatrix()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoDecomposeMatrix_initClass()

    initClass = staticmethod(initClass)
    matrix = _swig_property(_coin.SoDecomposeMatrix_matrix_get, _coin.SoDecomposeMatrix_matrix_set)
    center = _swig_property(_coin.SoDecomposeMatrix_center_get, _coin.SoDecomposeMatrix_center_set)
    translation = _swig_property(_coin.SoDecomposeMatrix_translation_get, _coin.SoDecomposeMatrix_translation_set)
    rotation = _swig_property(_coin.SoDecomposeMatrix_rotation_get, _coin.SoDecomposeMatrix_rotation_set)
    scaleFactor = _swig_property(_coin.SoDecomposeMatrix_scaleFactor_get, _coin.SoDecomposeMatrix_scaleFactor_set)
    scaleOrientation = _swig_property(_coin.SoDecomposeMatrix_scaleOrientation_get, _coin.SoDecomposeMatrix_scaleOrientation_set)
SoDecomposeMatrix_swigregister = _coin.SoDecomposeMatrix_swigregister
SoDecomposeMatrix_swigregister(SoDecomposeMatrix)

def SoDecomposeMatrix_getClassTypeId():
  """SoDecomposeMatrix_getClassTypeId() -> SoType"""
  return _coin.SoDecomposeMatrix_getClassTypeId()

def SoDecomposeMatrix_createInstance():
  """SoDecomposeMatrix_createInstance() -> void"""
  return _coin.SoDecomposeMatrix_createInstance()

def SoDecomposeMatrix_initClass():
  """SoDecomposeMatrix_initClass()"""
  return _coin.SoDecomposeMatrix_initClass()

class SoComposeRotationFromTo(SoEngine):
    """Proxy of C++ SoComposeRotationFromTo class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoComposeRotationFromTo_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoComposeRotationFromTo_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoComposeRotationFromTo_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoComposeRotationFromTo_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoComposeRotationFromTo_createInstance()

    createInstance = staticmethod(createInstance)
    def __init__(self): 
        """__init__(self) -> SoComposeRotationFromTo"""
        this = _coin.new_SoComposeRotationFromTo()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoComposeRotationFromTo_initClass()

    initClass = staticmethod(initClass)
    srcFrom = _swig_property(_coin.SoComposeRotationFromTo_srcFrom_get, _coin.SoComposeRotationFromTo_srcFrom_set)
    destTo = _swig_property(_coin.SoComposeRotationFromTo_destTo_get, _coin.SoComposeRotationFromTo_destTo_set)
    rotation = _swig_property(_coin.SoComposeRotationFromTo_rotation_get, _coin.SoComposeRotationFromTo_rotation_set)
SoComposeRotationFromTo_swigregister = _coin.SoComposeRotationFromTo_swigregister
SoComposeRotationFromTo_swigregister(SoComposeRotationFromTo)

def SoComposeRotationFromTo_getClassTypeId():
  """SoComposeRotationFromTo_getClassTypeId() -> SoType"""
  return _coin.SoComposeRotationFromTo_getClassTypeId()

def SoComposeRotationFromTo_createInstance():
  """SoComposeRotationFromTo_createInstance() -> void"""
  return _coin.SoComposeRotationFromTo_createInstance()

def SoComposeRotationFromTo_initClass():
  """SoComposeRotationFromTo_initClass()"""
  return _coin.SoComposeRotationFromTo_initClass()

class SoSFPath(SoSField):
    """Proxy of C++ SoSFPath class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFPath"""
        this = _coin.new_SoSFPath()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFPath
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFPath_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFPath_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFPath_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFPath_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFPath_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SoPath"""
        return _coin.SoSFPath_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFPath field) -> int"""
        return _coin.SoSFPath___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFPath field) -> int"""
        return _coin.SoSFPath___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFPath_initClass()

    initClass = staticmethod(initClass)
    def notify(self, *args):
        """notify(self, SoNotList l)"""
        return _coin.SoSFPath_notify(self, *args)

    def fixCopy(self, *args):
        """fixCopy(self, SbBool copyconnections)"""
        return _coin.SoSFPath_fixCopy(self, *args)

    def referencesCopy(self):
        """referencesCopy(self) -> SbBool"""
        return _coin.SoSFPath_referencesCopy(self)

    def setValue(self, *args):
        """
        setValue(self, SoPath newvalue)
        setValue(self, SoSFPath other)
        """
        return _coin.SoSFPath_setValue(self, *args)

SoSFPath_swigregister = _coin.SoSFPath_swigregister
SoSFPath_swigregister(SoSFPath)

def SoSFPath_createInstance():
  """SoSFPath_createInstance() -> void"""
  return _coin.SoSFPath_createInstance()

def SoSFPath_getClassTypeId():
  """SoSFPath_getClassTypeId() -> SoType"""
  return _coin.SoSFPath_getClassTypeId()

def SoSFPath_initClass():
  """SoSFPath_initClass()"""
  return _coin.SoSFPath_initClass()

class SoComputeBoundingBox(SoEngine):
    """Proxy of C++ SoComputeBoundingBox class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoComputeBoundingBox_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoComputeBoundingBox_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoComputeBoundingBox_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoComputeBoundingBox_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoComputeBoundingBox_createInstance()

    createInstance = staticmethod(createInstance)
    node = _swig_property(_coin.SoComputeBoundingBox_node_get, _coin.SoComputeBoundingBox_node_set)
    path = _swig_property(_coin.SoComputeBoundingBox_path_get, _coin.SoComputeBoundingBox_path_set)
    min = _swig_property(_coin.SoComputeBoundingBox_min_get, _coin.SoComputeBoundingBox_min_set)
    max = _swig_property(_coin.SoComputeBoundingBox_max_get, _coin.SoComputeBoundingBox_max_set)
    boxCenter = _swig_property(_coin.SoComputeBoundingBox_boxCenter_get, _coin.SoComputeBoundingBox_boxCenter_set)
    objectCenter = _swig_property(_coin.SoComputeBoundingBox_objectCenter_get, _coin.SoComputeBoundingBox_objectCenter_set)
    def __init__(self): 
        """__init__(self) -> SoComputeBoundingBox"""
        this = _coin.new_SoComputeBoundingBox()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoComputeBoundingBox_initClass()

    initClass = staticmethod(initClass)
    def setViewportRegion(self, *args):
        """setViewportRegion(self, SbViewportRegion vpr)"""
        return _coin.SoComputeBoundingBox_setViewportRegion(self, *args)

    def getViewportRegion(self):
        """getViewportRegion(self) -> SbViewportRegion"""
        return _coin.SoComputeBoundingBox_getViewportRegion(self)

SoComputeBoundingBox_swigregister = _coin.SoComputeBoundingBox_swigregister
SoComputeBoundingBox_swigregister(SoComputeBoundingBox)

def SoComputeBoundingBox_getClassTypeId():
  """SoComputeBoundingBox_getClassTypeId() -> SoType"""
  return _coin.SoComputeBoundingBox_getClassTypeId()

def SoComputeBoundingBox_createInstance():
  """SoComputeBoundingBox_createInstance() -> void"""
  return _coin.SoComputeBoundingBox_createInstance()

def SoComputeBoundingBox_initClass():
  """SoComputeBoundingBox_initClass()"""
  return _coin.SoComputeBoundingBox_initClass()

class SoConcatenate(SoEngine):
    """Proxy of C++ SoConcatenate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoConcatenate_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoConcatenate_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoConcatenate_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoConcatenate_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoConcatenate_createInstance()

    createInstance = staticmethod(createInstance)
    NUMINPUTS = _coin.SoConcatenate_NUMINPUTS
    def initClass():
        """initClass()"""
        return _coin.SoConcatenate_initClass()

    initClass = staticmethod(initClass)
    def __init__(self, *args): 
        """__init__(self, SoType inputType) -> SoConcatenate"""
        this = _coin.new_SoConcatenate(*args)
        try: self.this.append(this)
        except: self.this = this
    input = _swig_property(_coin.SoConcatenate_input_get, _coin.SoConcatenate_input_set)
    output = _swig_property(_coin.SoConcatenate_output_get, _coin.SoConcatenate_output_set)
SoConcatenate_swigregister = _coin.SoConcatenate_swigregister
SoConcatenate_swigregister(SoConcatenate)

def SoConcatenate_getClassTypeId():
  """SoConcatenate_getClassTypeId() -> SoType"""
  return _coin.SoConcatenate_getClassTypeId()

def SoConcatenate_createInstance():
  """SoConcatenate_createInstance() -> void"""
  return _coin.SoConcatenate_createInstance()

def SoConcatenate_initClass():
  """SoConcatenate_initClass()"""
  return _coin.SoConcatenate_initClass()

class SoSFTrigger(SoSField):
    """Proxy of C++ SoSFTrigger class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFTrigger"""
        this = _coin.new_SoSFTrigger()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFTrigger
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFTrigger_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFTrigger_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFTrigger_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFTrigger_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFTrigger_isSame(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFTrigger_initClass()

    initClass = staticmethod(initClass)
    def getValue(self):
        """getValue(self)"""
        return _coin.SoSFTrigger_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFTrigger trigger) -> int"""
        return _coin.SoSFTrigger___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFTrigger trigger) -> int"""
        return _coin.SoSFTrigger___ne__(self, *args)

    def startNotify(self):
        """startNotify(self)"""
        return _coin.SoSFTrigger_startNotify(self)

    def notify(self, *args):
        """notify(self, SoNotList l)"""
        return _coin.SoSFTrigger_notify(self, *args)

    def touch(self):
        """touch(self)"""
        return _coin.SoSFTrigger_touch(self)

    def setValue(self, *args):
        """
        setValue(self)
        setValue(self, SoSFTrigger other)
        """
        return _coin.SoSFTrigger_setValue(self, *args)

SoSFTrigger_swigregister = _coin.SoSFTrigger_swigregister
SoSFTrigger_swigregister(SoSFTrigger)

def SoSFTrigger_createInstance():
  """SoSFTrigger_createInstance() -> void"""
  return _coin.SoSFTrigger_createInstance()

def SoSFTrigger_getClassTypeId():
  """SoSFTrigger_getClassTypeId() -> SoType"""
  return _coin.SoSFTrigger_getClassTypeId()

def SoSFTrigger_initClass():
  """SoSFTrigger_initClass()"""
  return _coin.SoSFTrigger_initClass()

class SoSFShort(SoSField):
    """Proxy of C++ SoSFShort class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFShort"""
        this = _coin.new_SoSFShort()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFShort
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFShort_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFShort_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFShort_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFShort_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFShort_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> short"""
        return _coin.SoSFShort_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFShort field) -> int"""
        return _coin.SoSFShort___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFShort field) -> int"""
        return _coin.SoSFShort___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFShort_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, short newvalue)
        setValue(self, SoSFShort other)
        """
        return _coin.SoSFShort_setValue(self, *args)

SoSFShort_swigregister = _coin.SoSFShort_swigregister
SoSFShort_swigregister(SoSFShort)

def SoSFShort_createInstance():
  """SoSFShort_createInstance() -> void"""
  return _coin.SoSFShort_createInstance()

def SoSFShort_getClassTypeId():
  """SoSFShort_getClassTypeId() -> SoType"""
  return _coin.SoSFShort_getClassTypeId()

def SoSFShort_initClass():
  """SoSFShort_initClass()"""
  return _coin.SoSFShort_initClass()

class SoCounter(SoEngine):
    """Proxy of C++ SoCounter class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoCounter_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoCounter_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoCounter_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoCounter_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoCounter_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoCounter_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoCounter"""
        this = _coin.new_SoCounter()
        try: self.this.append(this)
        except: self.this = this
    min = _swig_property(_coin.SoCounter_min_get, _coin.SoCounter_min_set)
    max = _swig_property(_coin.SoCounter_max_get, _coin.SoCounter_max_set)
    step = _swig_property(_coin.SoCounter_step_get, _coin.SoCounter_step_set)
    trigger = _swig_property(_coin.SoCounter_trigger_get, _coin.SoCounter_trigger_set)
    reset = _swig_property(_coin.SoCounter_reset_get, _coin.SoCounter_reset_set)
    output = _swig_property(_coin.SoCounter_output_get, _coin.SoCounter_output_set)
    syncOut = _swig_property(_coin.SoCounter_syncOut_get, _coin.SoCounter_syncOut_set)
SoCounter_swigregister = _coin.SoCounter_swigregister
SoCounter_swigregister(SoCounter)

def SoCounter_getClassTypeId():
  """SoCounter_getClassTypeId() -> SoType"""
  return _coin.SoCounter_getClassTypeId()

def SoCounter_createInstance():
  """SoCounter_createInstance() -> void"""
  return _coin.SoCounter_createInstance()

def SoCounter_initClass():
  """SoCounter_initClass()"""
  return _coin.SoCounter_initClass()

class SoSFTime(SoSField):
    """Proxy of C++ SoSFTime class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFTime"""
        this = _coin.new_SoSFTime()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFTime
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFTime_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFTime_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFTime_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFTime_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFTime_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SbTime"""
        return _coin.SoSFTime_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFTime field) -> int"""
        return _coin.SoSFTime___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFTime field) -> int"""
        return _coin.SoSFTime___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFTime_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbTime newvalue)
        setValue(self, SbTime other)
        setValue(self, SoSFTime other)
        """
        return _coin.SoSFTime_setValue(self, *args)

SoSFTime_swigregister = _coin.SoSFTime_swigregister
SoSFTime_swigregister(SoSFTime)

def SoSFTime_createInstance():
  """SoSFTime_createInstance() -> void"""
  return _coin.SoSFTime_createInstance()

def SoSFTime_getClassTypeId():
  """SoSFTime_getClassTypeId() -> SoType"""
  return _coin.SoSFTime_getClassTypeId()

def SoSFTime_initClass():
  """SoSFTime_initClass()"""
  return _coin.SoSFTime_initClass()

class SoElapsedTime(SoEngine):
    """Proxy of C++ SoElapsedTime class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoElapsedTime_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoElapsedTime_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoElapsedTime_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoElapsedTime_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoElapsedTime_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoElapsedTime_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoElapsedTime"""
        this = _coin.new_SoElapsedTime()
        try: self.this.append(this)
        except: self.this = this
    timeIn = _swig_property(_coin.SoElapsedTime_timeIn_get, _coin.SoElapsedTime_timeIn_set)
    speed = _swig_property(_coin.SoElapsedTime_speed_get, _coin.SoElapsedTime_speed_set)
    on = _swig_property(_coin.SoElapsedTime_on_get, _coin.SoElapsedTime_on_set)
    pause = _swig_property(_coin.SoElapsedTime_pause_get, _coin.SoElapsedTime_pause_set)
    reset = _swig_property(_coin.SoElapsedTime_reset_get, _coin.SoElapsedTime_reset_set)
    timeOut = _swig_property(_coin.SoElapsedTime_timeOut_get, _coin.SoElapsedTime_timeOut_set)
SoElapsedTime_swigregister = _coin.SoElapsedTime_swigregister
SoElapsedTime_swigregister(SoElapsedTime)

def SoElapsedTime_getClassTypeId():
  """SoElapsedTime_getClassTypeId() -> SoType"""
  return _coin.SoElapsedTime_getClassTypeId()

def SoElapsedTime_createInstance():
  """SoElapsedTime_createInstance() -> void"""
  return _coin.SoElapsedTime_createInstance()

def SoElapsedTime_initClass():
  """SoElapsedTime_initClass()"""
  return _coin.SoElapsedTime_initClass()

class SoFieldConverter(SoEngine):
    """Proxy of C++ SoFieldConverter class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoFieldConverter_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoFieldConverter_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoFieldConverter_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoFieldConverter_getOutputData(self)

    def initClass():
        """initClass()"""
        return _coin.SoFieldConverter_initClass()

    initClass = staticmethod(initClass)
    def initClasses():
        """initClasses()"""
        return _coin.SoFieldConverter_initClasses()

    initClasses = staticmethod(initClasses)
    def getInput(self, *args):
        """getInput(self, SoType type) -> SoField"""
        return _coin.SoFieldConverter_getInput(self, *args)

    def getOutput(self, *args):
        """getOutput(self, SoType type) -> SoEngineOutput"""
        return _coin.SoFieldConverter_getOutput(self, *args)

    def getConnectedInput(self):
        """getConnectedInput(self) -> SoField"""
        return _coin.SoFieldConverter_getConnectedInput(self)

    def getForwardConnections(self, *args):
        """getForwardConnections(self, SoFieldList l) -> int"""
        return _coin.SoFieldConverter_getForwardConnections(self, *args)

SoFieldConverter_swigregister = _coin.SoFieldConverter_swigregister
SoFieldConverter_swigregister(SoFieldConverter)

def SoFieldConverter_getClassTypeId():
  """SoFieldConverter_getClassTypeId() -> SoType"""
  return _coin.SoFieldConverter_getClassTypeId()

def SoFieldConverter_initClass():
  """SoFieldConverter_initClass()"""
  return _coin.SoFieldConverter_initClass()

def SoFieldConverter_initClasses():
  """SoFieldConverter_initClasses()"""
  return _coin.SoFieldConverter_initClasses()

class SoGate(SoEngine):
    """Proxy of C++ SoGate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGate_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoGate_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoGate_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoGate_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoGate_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoGate_initClass()

    initClass = staticmethod(initClass)
    def __init__(self, *args): 
        """__init__(self, SoType type) -> SoGate"""
        this = _coin.new_SoGate(*args)
        try: self.this.append(this)
        except: self.this = this
    enable = _swig_property(_coin.SoGate_enable_get, _coin.SoGate_enable_set)
    trigger = _swig_property(_coin.SoGate_trigger_get, _coin.SoGate_trigger_set)
    input = _swig_property(_coin.SoGate_input_get, _coin.SoGate_input_set)
    output = _swig_property(_coin.SoGate_output_get, _coin.SoGate_output_set)
SoGate_swigregister = _coin.SoGate_swigregister
SoGate_swigregister(SoGate)

def SoGate_getClassTypeId():
  """SoGate_getClassTypeId() -> SoType"""
  return _coin.SoGate_getClassTypeId()

def SoGate_createInstance():
  """SoGate_createInstance() -> void"""
  return _coin.SoGate_createInstance()

def SoGate_initClass():
  """SoGate_initClass()"""
  return _coin.SoGate_initClass()

class SoInterpolate(SoEngine):
    """Proxy of C++ SoInterpolate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoInterpolate_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoInterpolate_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoInterpolate_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoInterpolate_getOutputData(self)

    def initClass():
        """initClass()"""
        return _coin.SoInterpolate_initClass()

    initClass = staticmethod(initClass)
    def initClasses():
        """initClasses()"""
        return _coin.SoInterpolate_initClasses()

    initClasses = staticmethod(initClasses)
    alpha = _swig_property(_coin.SoInterpolate_alpha_get, _coin.SoInterpolate_alpha_set)
    output = _swig_property(_coin.SoInterpolate_output_get, _coin.SoInterpolate_output_set)
SoInterpolate_swigregister = _coin.SoInterpolate_swigregister
SoInterpolate_swigregister(SoInterpolate)

def SoInterpolate_getClassTypeId():
  """SoInterpolate_getClassTypeId() -> SoType"""
  return _coin.SoInterpolate_getClassTypeId()

def SoInterpolate_initClass():
  """SoInterpolate_initClass()"""
  return _coin.SoInterpolate_initClass()

def SoInterpolate_initClasses():
  """SoInterpolate_initClasses()"""
  return _coin.SoInterpolate_initClasses()

class SoInterpolateFloat(SoInterpolate):
    """Proxy of C++ SoInterpolateFloat class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoInterpolateFloat_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoInterpolateFloat_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoInterpolateFloat_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoInterpolateFloat_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoInterpolateFloat_createInstance()

    createInstance = staticmethod(createInstance)
    def __init__(self): 
        """__init__(self) -> SoInterpolateFloat"""
        this = _coin.new_SoInterpolateFloat()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoInterpolateFloat_initClass()

    initClass = staticmethod(initClass)
    input0 = _swig_property(_coin.SoInterpolateFloat_input0_get, _coin.SoInterpolateFloat_input0_set)
    input1 = _swig_property(_coin.SoInterpolateFloat_input1_get, _coin.SoInterpolateFloat_input1_set)
SoInterpolateFloat_swigregister = _coin.SoInterpolateFloat_swigregister
SoInterpolateFloat_swigregister(SoInterpolateFloat)

def SoInterpolateFloat_getClassTypeId():
  """SoInterpolateFloat_getClassTypeId() -> SoType"""
  return _coin.SoInterpolateFloat_getClassTypeId()

def SoInterpolateFloat_createInstance():
  """SoInterpolateFloat_createInstance() -> void"""
  return _coin.SoInterpolateFloat_createInstance()

def SoInterpolateFloat_initClass():
  """SoInterpolateFloat_initClass()"""
  return _coin.SoInterpolateFloat_initClass()

class SoInterpolateVec2f(SoInterpolate):
    """Proxy of C++ SoInterpolateVec2f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoInterpolateVec2f_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoInterpolateVec2f_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoInterpolateVec2f_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoInterpolateVec2f_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoInterpolateVec2f_createInstance()

    createInstance = staticmethod(createInstance)
    def __init__(self): 
        """__init__(self) -> SoInterpolateVec2f"""
        this = _coin.new_SoInterpolateVec2f()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoInterpolateVec2f_initClass()

    initClass = staticmethod(initClass)
    input0 = _swig_property(_coin.SoInterpolateVec2f_input0_get, _coin.SoInterpolateVec2f_input0_set)
    input1 = _swig_property(_coin.SoInterpolateVec2f_input1_get, _coin.SoInterpolateVec2f_input1_set)
SoInterpolateVec2f_swigregister = _coin.SoInterpolateVec2f_swigregister
SoInterpolateVec2f_swigregister(SoInterpolateVec2f)

def SoInterpolateVec2f_getClassTypeId():
  """SoInterpolateVec2f_getClassTypeId() -> SoType"""
  return _coin.SoInterpolateVec2f_getClassTypeId()

def SoInterpolateVec2f_createInstance():
  """SoInterpolateVec2f_createInstance() -> void"""
  return _coin.SoInterpolateVec2f_createInstance()

def SoInterpolateVec2f_initClass():
  """SoInterpolateVec2f_initClass()"""
  return _coin.SoInterpolateVec2f_initClass()

class SoInterpolateVec3f(SoInterpolate):
    """Proxy of C++ SoInterpolateVec3f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoInterpolateVec3f_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoInterpolateVec3f_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoInterpolateVec3f_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoInterpolateVec3f_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoInterpolateVec3f_createInstance()

    createInstance = staticmethod(createInstance)
    def __init__(self): 
        """__init__(self) -> SoInterpolateVec3f"""
        this = _coin.new_SoInterpolateVec3f()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoInterpolateVec3f_initClass()

    initClass = staticmethod(initClass)
    input0 = _swig_property(_coin.SoInterpolateVec3f_input0_get, _coin.SoInterpolateVec3f_input0_set)
    input1 = _swig_property(_coin.SoInterpolateVec3f_input1_get, _coin.SoInterpolateVec3f_input1_set)
SoInterpolateVec3f_swigregister = _coin.SoInterpolateVec3f_swigregister
SoInterpolateVec3f_swigregister(SoInterpolateVec3f)

def SoInterpolateVec3f_getClassTypeId():
  """SoInterpolateVec3f_getClassTypeId() -> SoType"""
  return _coin.SoInterpolateVec3f_getClassTypeId()

def SoInterpolateVec3f_createInstance():
  """SoInterpolateVec3f_createInstance() -> void"""
  return _coin.SoInterpolateVec3f_createInstance()

def SoInterpolateVec3f_initClass():
  """SoInterpolateVec3f_initClass()"""
  return _coin.SoInterpolateVec3f_initClass()

class SoInterpolateVec4f(SoInterpolate):
    """Proxy of C++ SoInterpolateVec4f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoInterpolateVec4f_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoInterpolateVec4f_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoInterpolateVec4f_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoInterpolateVec4f_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoInterpolateVec4f_createInstance()

    createInstance = staticmethod(createInstance)
    def __init__(self): 
        """__init__(self) -> SoInterpolateVec4f"""
        this = _coin.new_SoInterpolateVec4f()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoInterpolateVec4f_initClass()

    initClass = staticmethod(initClass)
    input0 = _swig_property(_coin.SoInterpolateVec4f_input0_get, _coin.SoInterpolateVec4f_input0_set)
    input1 = _swig_property(_coin.SoInterpolateVec4f_input1_get, _coin.SoInterpolateVec4f_input1_set)
SoInterpolateVec4f_swigregister = _coin.SoInterpolateVec4f_swigregister
SoInterpolateVec4f_swigregister(SoInterpolateVec4f)

def SoInterpolateVec4f_getClassTypeId():
  """SoInterpolateVec4f_getClassTypeId() -> SoType"""
  return _coin.SoInterpolateVec4f_getClassTypeId()

def SoInterpolateVec4f_createInstance():
  """SoInterpolateVec4f_createInstance() -> void"""
  return _coin.SoInterpolateVec4f_createInstance()

def SoInterpolateVec4f_initClass():
  """SoInterpolateVec4f_initClass()"""
  return _coin.SoInterpolateVec4f_initClass()

class SoInterpolateRotation(SoInterpolate):
    """Proxy of C++ SoInterpolateRotation class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoInterpolateRotation_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoInterpolateRotation_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoInterpolateRotation_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoInterpolateRotation_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoInterpolateRotation_createInstance()

    createInstance = staticmethod(createInstance)
    def __init__(self): 
        """__init__(self) -> SoInterpolateRotation"""
        this = _coin.new_SoInterpolateRotation()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoInterpolateRotation_initClass()

    initClass = staticmethod(initClass)
    input0 = _swig_property(_coin.SoInterpolateRotation_input0_get, _coin.SoInterpolateRotation_input0_set)
    input1 = _swig_property(_coin.SoInterpolateRotation_input1_get, _coin.SoInterpolateRotation_input1_set)
SoInterpolateRotation_swigregister = _coin.SoInterpolateRotation_swigregister
SoInterpolateRotation_swigregister(SoInterpolateRotation)

def SoInterpolateRotation_getClassTypeId():
  """SoInterpolateRotation_getClassTypeId() -> SoType"""
  return _coin.SoInterpolateRotation_getClassTypeId()

def SoInterpolateRotation_createInstance():
  """SoInterpolateRotation_createInstance() -> void"""
  return _coin.SoInterpolateRotation_createInstance()

def SoInterpolateRotation_initClass():
  """SoInterpolateRotation_initClass()"""
  return _coin.SoInterpolateRotation_initClass()

class SoOnOff(SoEngine):
    """Proxy of C++ SoOnOff class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoOnOff_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoOnOff_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoOnOff_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoOnOff_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoOnOff_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoOnOff_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoOnOff"""
        this = _coin.new_SoOnOff()
        try: self.this.append(this)
        except: self.this = this
    on = _swig_property(_coin.SoOnOff_on_get, _coin.SoOnOff_on_set)
    off = _swig_property(_coin.SoOnOff_off_get, _coin.SoOnOff_off_set)
    toggle = _swig_property(_coin.SoOnOff_toggle_get, _coin.SoOnOff_toggle_set)
    isOn = _swig_property(_coin.SoOnOff_isOn_get, _coin.SoOnOff_isOn_set)
    isOff = _swig_property(_coin.SoOnOff_isOff_get, _coin.SoOnOff_isOff_set)
SoOnOff_swigregister = _coin.SoOnOff_swigregister
SoOnOff_swigregister(SoOnOff)

def SoOnOff_getClassTypeId():
  """SoOnOff_getClassTypeId() -> SoType"""
  return _coin.SoOnOff_getClassTypeId()

def SoOnOff_createInstance():
  """SoOnOff_createInstance() -> void"""
  return _coin.SoOnOff_createInstance()

def SoOnOff_initClass():
  """SoOnOff_initClass()"""
  return _coin.SoOnOff_initClass()

class SoSFBitMask(SoSFEnum):
    """Proxy of C++ SoSFBitMask class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFBitMask"""
        this = _coin.new_SoSFBitMask()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFBitMask
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFBitMask_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFBitMask_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFBitMask_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFBitMask_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFBitMask_isSame(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFBitMask_initClass()

    initClass = staticmethod(initClass)
SoSFBitMask_swigregister = _coin.SoSFBitMask_swigregister
SoSFBitMask_swigregister(SoSFBitMask)

def SoSFBitMask_createInstance():
  """SoSFBitMask_createInstance() -> void"""
  return _coin.SoSFBitMask_createInstance()

def SoSFBitMask_getClassTypeId():
  """SoSFBitMask_getClassTypeId() -> SoType"""
  return _coin.SoSFBitMask_getClassTypeId()

def SoSFBitMask_initClass():
  """SoSFBitMask_initClass()"""
  return _coin.SoSFBitMask_initClass()

class SoOneShot(SoEngine):
    """Proxy of C++ SoOneShot class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoOneShot_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoOneShot_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoOneShot_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoOneShot_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoOneShot_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoOneShot_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoOneShot"""
        this = _coin.new_SoOneShot()
        try: self.this.append(this)
        except: self.this = this
    RETRIGGERABLE = _coin.SoOneShot_RETRIGGERABLE
    HOLD_FINAL = _coin.SoOneShot_HOLD_FINAL
    timeIn = _swig_property(_coin.SoOneShot_timeIn_get, _coin.SoOneShot_timeIn_set)
    duration = _swig_property(_coin.SoOneShot_duration_get, _coin.SoOneShot_duration_set)
    trigger = _swig_property(_coin.SoOneShot_trigger_get, _coin.SoOneShot_trigger_set)
    flags = _swig_property(_coin.SoOneShot_flags_get, _coin.SoOneShot_flags_set)
    disable = _swig_property(_coin.SoOneShot_disable_get, _coin.SoOneShot_disable_set)
    timeOut = _swig_property(_coin.SoOneShot_timeOut_get, _coin.SoOneShot_timeOut_set)
    isActive = _swig_property(_coin.SoOneShot_isActive_get, _coin.SoOneShot_isActive_set)
    ramp = _swig_property(_coin.SoOneShot_ramp_get, _coin.SoOneShot_ramp_set)
SoOneShot_swigregister = _coin.SoOneShot_swigregister
SoOneShot_swigregister(SoOneShot)

def SoOneShot_getClassTypeId():
  """SoOneShot_getClassTypeId() -> SoType"""
  return _coin.SoOneShot_getClassTypeId()

def SoOneShot_createInstance():
  """SoOneShot_createInstance() -> void"""
  return _coin.SoOneShot_createInstance()

def SoOneShot_initClass():
  """SoOneShot_initClass()"""
  return _coin.SoOneShot_initClass()

class SoSelectOne(SoEngine):
    """Proxy of C++ SoSelectOne class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSelectOne_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSelectOne_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoSelectOne_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoSelectOne_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSelectOne_createInstance()

    createInstance = staticmethod(createInstance)
    index = _swig_property(_coin.SoSelectOne_index_get, _coin.SoSelectOne_index_set)
    input = _swig_property(_coin.SoSelectOne_input_get, _coin.SoSelectOne_input_set)
    output = _swig_property(_coin.SoSelectOne_output_get, _coin.SoSelectOne_output_set)
    def __init__(self, *args): 
        """__init__(self, SoType inputtype) -> SoSelectOne"""
        this = _coin.new_SoSelectOne(*args)
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoSelectOne_initClass()

    initClass = staticmethod(initClass)
SoSelectOne_swigregister = _coin.SoSelectOne_swigregister
SoSelectOne_swigregister(SoSelectOne)

def SoSelectOne_getClassTypeId():
  """SoSelectOne_getClassTypeId() -> SoType"""
  return _coin.SoSelectOne_getClassTypeId()

def SoSelectOne_createInstance():
  """SoSelectOne_createInstance() -> void"""
  return _coin.SoSelectOne_createInstance()

def SoSelectOne_initClass():
  """SoSelectOne_initClass()"""
  return _coin.SoSelectOne_initClass()

class SoTimeCounter(SoEngine):
    """Proxy of C++ SoTimeCounter class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTimeCounter_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTimeCounter_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoTimeCounter_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoTimeCounter_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoTimeCounter_createInstance()

    createInstance = staticmethod(createInstance)
    timeIn = _swig_property(_coin.SoTimeCounter_timeIn_get, _coin.SoTimeCounter_timeIn_set)
    min = _swig_property(_coin.SoTimeCounter_min_get, _coin.SoTimeCounter_min_set)
    max = _swig_property(_coin.SoTimeCounter_max_get, _coin.SoTimeCounter_max_set)
    step = _swig_property(_coin.SoTimeCounter_step_get, _coin.SoTimeCounter_step_set)
    on = _swig_property(_coin.SoTimeCounter_on_get, _coin.SoTimeCounter_on_set)
    frequency = _swig_property(_coin.SoTimeCounter_frequency_get, _coin.SoTimeCounter_frequency_set)
    duty = _swig_property(_coin.SoTimeCounter_duty_get, _coin.SoTimeCounter_duty_set)
    reset = _swig_property(_coin.SoTimeCounter_reset_get, _coin.SoTimeCounter_reset_set)
    syncIn = _swig_property(_coin.SoTimeCounter_syncIn_get, _coin.SoTimeCounter_syncIn_set)
    output = _swig_property(_coin.SoTimeCounter_output_get, _coin.SoTimeCounter_output_set)
    syncOut = _swig_property(_coin.SoTimeCounter_syncOut_get, _coin.SoTimeCounter_syncOut_set)
    def __init__(self): 
        """__init__(self) -> SoTimeCounter"""
        this = _coin.new_SoTimeCounter()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoTimeCounter_initClass()

    initClass = staticmethod(initClass)
SoTimeCounter_swigregister = _coin.SoTimeCounter_swigregister
SoTimeCounter_swigregister(SoTimeCounter)

def SoTimeCounter_getClassTypeId():
  """SoTimeCounter_getClassTypeId() -> SoType"""
  return _coin.SoTimeCounter_getClassTypeId()

def SoTimeCounter_createInstance():
  """SoTimeCounter_createInstance() -> void"""
  return _coin.SoTimeCounter_createInstance()

def SoTimeCounter_initClass():
  """SoTimeCounter_initClass()"""
  return _coin.SoTimeCounter_initClass()

class SoTransformVec3f(SoEngine):
    """Proxy of C++ SoTransformVec3f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTransformVec3f_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTransformVec3f_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoTransformVec3f_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoTransformVec3f_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoTransformVec3f_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoTransformVec3f_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTransformVec3f"""
        this = _coin.new_SoTransformVec3f()
        try: self.this.append(this)
        except: self.this = this
    vector = _swig_property(_coin.SoTransformVec3f_vector_get, _coin.SoTransformVec3f_vector_set)
    matrix = _swig_property(_coin.SoTransformVec3f_matrix_get, _coin.SoTransformVec3f_matrix_set)
    point = _swig_property(_coin.SoTransformVec3f_point_get, _coin.SoTransformVec3f_point_set)
    direction = _swig_property(_coin.SoTransformVec3f_direction_get, _coin.SoTransformVec3f_direction_set)
    normalDirection = _swig_property(_coin.SoTransformVec3f_normalDirection_get, _coin.SoTransformVec3f_normalDirection_set)
SoTransformVec3f_swigregister = _coin.SoTransformVec3f_swigregister
SoTransformVec3f_swigregister(SoTransformVec3f)

def SoTransformVec3f_getClassTypeId():
  """SoTransformVec3f_getClassTypeId() -> SoType"""
  return _coin.SoTransformVec3f_getClassTypeId()

def SoTransformVec3f_createInstance():
  """SoTransformVec3f_createInstance() -> void"""
  return _coin.SoTransformVec3f_createInstance()

def SoTransformVec3f_initClass():
  """SoTransformVec3f_initClass()"""
  return _coin.SoTransformVec3f_initClass()

class SoTriggerAny(SoEngine):
    """Proxy of C++ SoTriggerAny class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTriggerAny_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTriggerAny_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoTriggerAny_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoTriggerAny_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoTriggerAny_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoTriggerAny_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTriggerAny"""
        this = _coin.new_SoTriggerAny()
        try: self.this.append(this)
        except: self.this = this
    input0 = _swig_property(_coin.SoTriggerAny_input0_get, _coin.SoTriggerAny_input0_set)
    input1 = _swig_property(_coin.SoTriggerAny_input1_get, _coin.SoTriggerAny_input1_set)
    input2 = _swig_property(_coin.SoTriggerAny_input2_get, _coin.SoTriggerAny_input2_set)
    input3 = _swig_property(_coin.SoTriggerAny_input3_get, _coin.SoTriggerAny_input3_set)
    input4 = _swig_property(_coin.SoTriggerAny_input4_get, _coin.SoTriggerAny_input4_set)
    input5 = _swig_property(_coin.SoTriggerAny_input5_get, _coin.SoTriggerAny_input5_set)
    input6 = _swig_property(_coin.SoTriggerAny_input6_get, _coin.SoTriggerAny_input6_set)
    input7 = _swig_property(_coin.SoTriggerAny_input7_get, _coin.SoTriggerAny_input7_set)
    input8 = _swig_property(_coin.SoTriggerAny_input8_get, _coin.SoTriggerAny_input8_set)
    input9 = _swig_property(_coin.SoTriggerAny_input9_get, _coin.SoTriggerAny_input9_set)
    output = _swig_property(_coin.SoTriggerAny_output_get, _coin.SoTriggerAny_output_set)
SoTriggerAny_swigregister = _coin.SoTriggerAny_swigregister
SoTriggerAny_swigregister(SoTriggerAny)

def SoTriggerAny_getClassTypeId():
  """SoTriggerAny_getClassTypeId() -> SoType"""
  return _coin.SoTriggerAny_getClassTypeId()

def SoTriggerAny_createInstance():
  """SoTriggerAny_createInstance() -> void"""
  return _coin.SoTriggerAny_createInstance()

def SoTriggerAny_initClass():
  """SoTriggerAny_initClass()"""
  return _coin.SoTriggerAny_initClass()

class SoTexture2Convert(SoEngine):
    """Proxy of C++ SoTexture2Convert class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTexture2Convert_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTexture2Convert_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoTexture2Convert_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoTexture2Convert_getOutputData(self)

    def initClass():
        """initClass()"""
        return _coin.SoTexture2Convert_initClass()

    initClass = staticmethod(initClass)
    sourceImage = _swig_property(_coin.SoTexture2Convert_sourceImage_get, _coin.SoTexture2Convert_sourceImage_set)
    image = _swig_property(_coin.SoTexture2Convert_image_get, _coin.SoTexture2Convert_image_set)
    __swig_destroy__ = _coin.delete_SoTexture2Convert
    __del__ = lambda self : None;
SoTexture2Convert_swigregister = _coin.SoTexture2Convert_swigregister
SoTexture2Convert_swigregister(SoTexture2Convert)

def SoTexture2Convert_getClassTypeId():
  """SoTexture2Convert_getClassTypeId() -> SoType"""
  return _coin.SoTexture2Convert_getClassTypeId()

def SoTexture2Convert_initClass():
  """SoTexture2Convert_initClass()"""
  return _coin.SoTexture2Convert_initClass()

class SoHeightMapToNormalMap(SoTexture2Convert):
    """Proxy of C++ SoHeightMapToNormalMap class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoHeightMapToNormalMap_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoHeightMapToNormalMap_getTypeId(self)

    def getFieldData(self):
        """getFieldData(self) -> SoFieldData"""
        return _coin.SoHeightMapToNormalMap_getFieldData(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoHeightMapToNormalMap_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoHeightMapToNormalMap_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoHeightMapToNormalMap_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoHeightMapToNormalMap"""
        this = _coin.new_SoHeightMapToNormalMap()
        try: self.this.append(this)
        except: self.this = this
    INT8 = _coin.SoHeightMapToNormalMap_INT8
    format = _swig_property(_coin.SoHeightMapToNormalMap_format_get, _coin.SoHeightMapToNormalMap_format_set)
    def convert(*args):
        """convert(unsigned char srcptr, SbVec2s size, int nc, SbImage dst_out)"""
        return _coin.SoHeightMapToNormalMap_convert(*args)

    convert = staticmethod(convert)
    __swig_destroy__ = _coin.delete_SoHeightMapToNormalMap
    __del__ = lambda self : None;
SoHeightMapToNormalMap_swigregister = _coin.SoHeightMapToNormalMap_swigregister
SoHeightMapToNormalMap_swigregister(SoHeightMapToNormalMap)

def SoHeightMapToNormalMap_getClassTypeId():
  """SoHeightMapToNormalMap_getClassTypeId() -> SoType"""
  return _coin.SoHeightMapToNormalMap_getClassTypeId()

def SoHeightMapToNormalMap_createInstance():
  """SoHeightMapToNormalMap_createInstance() -> void"""
  return _coin.SoHeightMapToNormalMap_createInstance()

def SoHeightMapToNormalMap_initClass():
  """SoHeightMapToNormalMap_initClass()"""
  return _coin.SoHeightMapToNormalMap_initClass()

def SoHeightMapToNormalMap_convert(*args):
  """SoHeightMapToNormalMap_convert(unsigned char srcptr, SbVec2s size, int nc, SbImage dst_out)"""
  return _coin.SoHeightMapToNormalMap_convert(*args)

class SoNodeEngine(SoNode):
    """Proxy of C++ SoNodeEngine class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def initClass():
        """initClass()"""
        return _coin.SoNodeEngine_initClass()

    initClass = staticmethod(initClass)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoNodeEngine_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def evaluateWrapper(self):
        """evaluateWrapper(self)"""
        return _coin.SoNodeEngine_evaluateWrapper(self)

    def getOutputs(self, *args):
        """getOutputs(self, SoEngineOutputList l) -> int"""
        return _coin.SoNodeEngine_getOutputs(self, *args)

    def getOutput(self, *args):
        """getOutput(self, SbName outputname) -> SoEngineOutput"""
        return _coin.SoNodeEngine_getOutput(self, *args)

    def getOutputName(self, *args):
        """getOutputName(self, SoEngineOutput output, SbName outputname) -> SbBool"""
        return _coin.SoNodeEngine_getOutputName(self, *args)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoNodeEngine_getOutputData(self)

    def isNotifying(self):
        """isNotifying(self) -> SbBool"""
        return _coin.SoNodeEngine_isNotifying(self)

    def notify(self, *args):
        """notify(self, SoNotList nl)"""
        return _coin.SoNodeEngine_notify(self, *args)

    def writeInstance(self, *args):
        """writeInstance(self, SoOutput out)"""
        return _coin.SoNodeEngine_writeInstance(self, *args)

SoNodeEngine_swigregister = _coin.SoNodeEngine_swigregister
SoNodeEngine_swigregister(SoNodeEngine)

def SoNodeEngine_initClass():
  """SoNodeEngine_initClass()"""
  return _coin.SoNodeEngine_initClass()

def SoNodeEngine_getClassTypeId():
  """SoNodeEngine_getClassTypeId() -> SoType"""
  return _coin.SoNodeEngine_getClassTypeId()

class SoMemoryError(SoError):
    """Proxy of C++ SoMemoryError class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def setHandlerCallback(*args):
        """setHandlerCallback(SoErrorCB callback, void data)"""
        return _coin.SoMemoryError_setHandlerCallback(*args)

    setHandlerCallback = staticmethod(setHandlerCallback)
    def getHandlerCallback():
        """getHandlerCallback() -> SoErrorCB"""
        return _coin.SoMemoryError_getHandlerCallback()

    getHandlerCallback = staticmethod(getHandlerCallback)
    def getHandlerData():
        """getHandlerData() -> void"""
        return _coin.SoMemoryError_getHandlerData()

    getHandlerData = staticmethod(getHandlerData)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMemoryError_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMemoryError_getTypeId(self)

    def post(*args):
        """post(char whatWasAllocated)"""
        return _coin.SoMemoryError_post(*args)

    post = staticmethod(post)
    def initClass():
        """initClass()"""
        return _coin.SoMemoryError_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoMemoryError"""
        this = _coin.new_SoMemoryError()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMemoryError
    __del__ = lambda self : None;
SoMemoryError_swigregister = _coin.SoMemoryError_swigregister
SoMemoryError_swigregister(SoMemoryError)

def SoMemoryError_setHandlerCallback(*args):
  """SoMemoryError_setHandlerCallback(SoErrorCB callback, void data)"""
  return _coin.SoMemoryError_setHandlerCallback(*args)

def SoMemoryError_getHandlerCallback():
  """SoMemoryError_getHandlerCallback() -> SoErrorCB"""
  return _coin.SoMemoryError_getHandlerCallback()

def SoMemoryError_getHandlerData():
  """SoMemoryError_getHandlerData() -> void"""
  return _coin.SoMemoryError_getHandlerData()

def SoMemoryError_getClassTypeId():
  """SoMemoryError_getClassTypeId() -> SoType"""
  return _coin.SoMemoryError_getClassTypeId()

def SoMemoryError_post(*args):
  """SoMemoryError_post(char whatWasAllocated)"""
  return _coin.SoMemoryError_post(*args)

def SoMemoryError_initClass():
  """SoMemoryError_initClass()"""
  return _coin.SoMemoryError_initClass()

class SoReadError(SoError):
    """Proxy of C++ SoReadError class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def setHandlerCallback(*args):
        """setHandlerCallback(SoErrorCB function, void data)"""
        return _coin.SoReadError_setHandlerCallback(*args)

    setHandlerCallback = staticmethod(setHandlerCallback)
    def getHandlerCallback():
        """getHandlerCallback() -> SoErrorCB"""
        return _coin.SoReadError_getHandlerCallback()

    getHandlerCallback = staticmethod(getHandlerCallback)
    def getHandlerData():
        """getHandlerData() -> void"""
        return _coin.SoReadError_getHandlerData()

    getHandlerData = staticmethod(getHandlerData)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoReadError_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoReadError_getTypeId(self)

    def post(*args):
        """post(SoInput input, char format, v(...) *args)"""
        return _coin.SoReadError_post(*args)

    post = staticmethod(post)
    def initClass():
        """initClass()"""
        return _coin.SoReadError_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoReadError"""
        this = _coin.new_SoReadError()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoReadError
    __del__ = lambda self : None;
SoReadError_swigregister = _coin.SoReadError_swigregister
SoReadError_swigregister(SoReadError)

def SoReadError_setHandlerCallback(*args):
  """SoReadError_setHandlerCallback(SoErrorCB function, void data)"""
  return _coin.SoReadError_setHandlerCallback(*args)

def SoReadError_getHandlerCallback():
  """SoReadError_getHandlerCallback() -> SoErrorCB"""
  return _coin.SoReadError_getHandlerCallback()

def SoReadError_getHandlerData():
  """SoReadError_getHandlerData() -> void"""
  return _coin.SoReadError_getHandlerData()

def SoReadError_getClassTypeId():
  """SoReadError_getClassTypeId() -> SoType"""
  return _coin.SoReadError_getClassTypeId()

def SoReadError_post(*args):
  """SoReadError_post(SoInput input, char format, v(...) *args)"""
  return _coin.SoReadError_post(*args)

def SoReadError_initClass():
  """SoReadError_initClass()"""
  return _coin.SoReadError_initClass()

class SoButtonEvent(SoEvent):
    """Proxy of C++ SoButtonEvent class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoButtonEvent_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoButtonEvent_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoButtonEvent_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoButtonEvent"""
        this = _coin.new_SoButtonEvent()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoButtonEvent
    __del__ = lambda self : None;
    UP = _coin.SoButtonEvent_UP
    DOWN = _coin.SoButtonEvent_DOWN
    UNKNOWN = _coin.SoButtonEvent_UNKNOWN
    def setState(self, *args):
        """setState(self, State state)"""
        return _coin.SoButtonEvent_setState(self, *args)

    def getState(self):
        """getState(self) -> State"""
        return _coin.SoButtonEvent_getState(self)

    def enumToString(*args):
        """enumToString(State enumval, SbString stringrep) -> SbBool"""
        return _coin.SoButtonEvent_enumToString(*args)

    enumToString = staticmethod(enumToString)
SoButtonEvent_swigregister = _coin.SoButtonEvent_swigregister
SoButtonEvent_swigregister(SoButtonEvent)

def SoButtonEvent_getClassTypeId():
  """SoButtonEvent_getClassTypeId() -> SoType"""
  return _coin.SoButtonEvent_getClassTypeId()

def SoButtonEvent_initClass():
  """SoButtonEvent_initClass()"""
  return _coin.SoButtonEvent_initClass()

def SoButtonEvent_enumToString(*args):
  """SoButtonEvent_enumToString(State enumval, SbString stringrep) -> SbBool"""
  return _coin.SoButtonEvent_enumToString(*args)

class SoLocation2Event(SoEvent):
    """Proxy of C++ SoLocation2Event class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoLocation2Event_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoLocation2Event_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoLocation2Event_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoLocation2Event"""
        this = _coin.new_SoLocation2Event()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoLocation2Event
    __del__ = lambda self : None;
SoLocation2Event_swigregister = _coin.SoLocation2Event_swigregister
SoLocation2Event_swigregister(SoLocation2Event)

def SoLocation2Event_getClassTypeId():
  """SoLocation2Event_getClassTypeId() -> SoType"""
  return _coin.SoLocation2Event_getClassTypeId()

def SoLocation2Event_initClass():
  """SoLocation2Event_initClass()"""
  return _coin.SoLocation2Event_initClass()

class SoMotion3Event(SoEvent):
    """Proxy of C++ SoMotion3Event class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMotion3Event_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMotion3Event_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoMotion3Event_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoMotion3Event"""
        this = _coin.new_SoMotion3Event()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMotion3Event
    __del__ = lambda self : None;
    def setTranslation(self, *args):
        """setTranslation(self, SbVec3f t)"""
        return _coin.SoMotion3Event_setTranslation(self, *args)

    def getTranslation(self):
        """getTranslation(self) -> SbVec3f"""
        return _coin.SoMotion3Event_getTranslation(self)

    def setRotation(self, *args):
        """setRotation(self, SbRotation r)"""
        return _coin.SoMotion3Event_setRotation(self, *args)

    def getRotation(self):
        """getRotation(self) -> SbRotation"""
        return _coin.SoMotion3Event_getRotation(self)

SoMotion3Event_swigregister = _coin.SoMotion3Event_swigregister
SoMotion3Event_swigregister(SoMotion3Event)

def SoMotion3Event_getClassTypeId():
  """SoMotion3Event_getClassTypeId() -> SoType"""
  return _coin.SoMotion3Event_getClassTypeId()

def SoMotion3Event_initClass():
  """SoMotion3Event_initClass()"""
  return _coin.SoMotion3Event_initClass()

class SoKeyboardEvent(SoButtonEvent):
    """Proxy of C++ SoKeyboardEvent class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoKeyboardEvent_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoKeyboardEvent_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoKeyboardEvent_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoKeyboardEvent"""
        this = _coin.new_SoKeyboardEvent()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoKeyboardEvent
    __del__ = lambda self : None;
    ANY = _coin.SoKeyboardEvent_ANY
    UNDEFINED = _coin.SoKeyboardEvent_UNDEFINED
    LEFT_SHIFT = _coin.SoKeyboardEvent_LEFT_SHIFT
    RIGHT_SHIFT = _coin.SoKeyboardEvent_RIGHT_SHIFT
    LEFT_CONTROL = _coin.SoKeyboardEvent_LEFT_CONTROL
    RIGHT_CONTROL = _coin.SoKeyboardEvent_RIGHT_CONTROL
    LEFT_ALT = _coin.SoKeyboardEvent_LEFT_ALT
    RIGHT_ALT = _coin.SoKeyboardEvent_RIGHT_ALT
    NUMBER_0 = _coin.SoKeyboardEvent_NUMBER_0
    NUMBER_1 = _coin.SoKeyboardEvent_NUMBER_1
    NUMBER_2 = _coin.SoKeyboardEvent_NUMBER_2
    NUMBER_3 = _coin.SoKeyboardEvent_NUMBER_3
    NUMBER_4 = _coin.SoKeyboardEvent_NUMBER_4
    NUMBER_5 = _coin.SoKeyboardEvent_NUMBER_5
    NUMBER_6 = _coin.SoKeyboardEvent_NUMBER_6
    NUMBER_7 = _coin.SoKeyboardEvent_NUMBER_7
    NUMBER_8 = _coin.SoKeyboardEvent_NUMBER_8
    NUMBER_9 = _coin.SoKeyboardEvent_NUMBER_9
    A = _coin.SoKeyboardEvent_A
    B = _coin.SoKeyboardEvent_B
    C = _coin.SoKeyboardEvent_C
    D = _coin.SoKeyboardEvent_D
    E = _coin.SoKeyboardEvent_E
    F = _coin.SoKeyboardEvent_F
    G = _coin.SoKeyboardEvent_G
    H = _coin.SoKeyboardEvent_H
    I = _coin.SoKeyboardEvent_I
    J = _coin.SoKeyboardEvent_J
    K = _coin.SoKeyboardEvent_K
    L = _coin.SoKeyboardEvent_L
    M = _coin.SoKeyboardEvent_M
    N = _coin.SoKeyboardEvent_N
    O = _coin.SoKeyboardEvent_O
    P = _coin.SoKeyboardEvent_P
    Q = _coin.SoKeyboardEvent_Q
    R = _coin.SoKeyboardEvent_R
    S = _coin.SoKeyboardEvent_S
    T = _coin.SoKeyboardEvent_T
    U = _coin.SoKeyboardEvent_U
    V = _coin.SoKeyboardEvent_V
    W = _coin.SoKeyboardEvent_W
    X = _coin.SoKeyboardEvent_X
    Y = _coin.SoKeyboardEvent_Y
    Z = _coin.SoKeyboardEvent_Z
    HOME = _coin.SoKeyboardEvent_HOME
    LEFT_ARROW = _coin.SoKeyboardEvent_LEFT_ARROW
    UP_ARROW = _coin.SoKeyboardEvent_UP_ARROW
    RIGHT_ARROW = _coin.SoKeyboardEvent_RIGHT_ARROW
    DOWN_ARROW = _coin.SoKeyboardEvent_DOWN_ARROW
    PAGE_UP = _coin.SoKeyboardEvent_PAGE_UP
    PAGE_DOWN = _coin.SoKeyboardEvent_PAGE_DOWN
    END = _coin.SoKeyboardEvent_END
    PRIOR = _coin.SoKeyboardEvent_PRIOR
    NEXT = _coin.SoKeyboardEvent_NEXT
    PAD_ENTER = _coin.SoKeyboardEvent_PAD_ENTER
    PAD_F1 = _coin.SoKeyboardEvent_PAD_F1
    PAD_F2 = _coin.SoKeyboardEvent_PAD_F2
    PAD_F3 = _coin.SoKeyboardEvent_PAD_F3
    PAD_F4 = _coin.SoKeyboardEvent_PAD_F4
    PAD_0 = _coin.SoKeyboardEvent_PAD_0
    PAD_1 = _coin.SoKeyboardEvent_PAD_1
    PAD_2 = _coin.SoKeyboardEvent_PAD_2
    PAD_3 = _coin.SoKeyboardEvent_PAD_3
    PAD_4 = _coin.SoKeyboardEvent_PAD_4
    PAD_5 = _coin.SoKeyboardEvent_PAD_5
    PAD_6 = _coin.SoKeyboardEvent_PAD_6
    PAD_7 = _coin.SoKeyboardEvent_PAD_7
    PAD_8 = _coin.SoKeyboardEvent_PAD_8
    PAD_9 = _coin.SoKeyboardEvent_PAD_9
    PAD_ADD = _coin.SoKeyboardEvent_PAD_ADD
    PAD_SUBTRACT = _coin.SoKeyboardEvent_PAD_SUBTRACT
    PAD_MULTIPLY = _coin.SoKeyboardEvent_PAD_MULTIPLY
    PAD_DIVIDE = _coin.SoKeyboardEvent_PAD_DIVIDE
    PAD_SPACE = _coin.SoKeyboardEvent_PAD_SPACE
    PAD_TAB = _coin.SoKeyboardEvent_PAD_TAB
    PAD_INSERT = _coin.SoKeyboardEvent_PAD_INSERT
    PAD_DELETE = _coin.SoKeyboardEvent_PAD_DELETE
    PAD_PERIOD = _coin.SoKeyboardEvent_PAD_PERIOD
    F1 = _coin.SoKeyboardEvent_F1
    F2 = _coin.SoKeyboardEvent_F2
    F3 = _coin.SoKeyboardEvent_F3
    F4 = _coin.SoKeyboardEvent_F4
    F5 = _coin.SoKeyboardEvent_F5
    F6 = _coin.SoKeyboardEvent_F6
    F7 = _coin.SoKeyboardEvent_F7
    F8 = _coin.SoKeyboardEvent_F8
    F9 = _coin.SoKeyboardEvent_F9
    F10 = _coin.SoKeyboardEvent_F10
    F11 = _coin.SoKeyboardEvent_F11
    F12 = _coin.SoKeyboardEvent_F12
    BACKSPACE = _coin.SoKeyboardEvent_BACKSPACE
    TAB = _coin.SoKeyboardEvent_TAB
    RETURN = _coin.SoKeyboardEvent_RETURN
    ENTER = _coin.SoKeyboardEvent_ENTER
    PAUSE = _coin.SoKeyboardEvent_PAUSE
    SCROLL_LOCK = _coin.SoKeyboardEvent_SCROLL_LOCK
    ESCAPE = _coin.SoKeyboardEvent_ESCAPE
    DELETE = _coin.SoKeyboardEvent_DELETE
    KEY_DELETE = _coin.SoKeyboardEvent_KEY_DELETE
    PRINT = _coin.SoKeyboardEvent_PRINT
    INSERT = _coin.SoKeyboardEvent_INSERT
    NUM_LOCK = _coin.SoKeyboardEvent_NUM_LOCK
    CAPS_LOCK = _coin.SoKeyboardEvent_CAPS_LOCK
    SHIFT_LOCK = _coin.SoKeyboardEvent_SHIFT_LOCK
    SPACE = _coin.SoKeyboardEvent_SPACE
    APOSTROPHE = _coin.SoKeyboardEvent_APOSTROPHE
    COMMA = _coin.SoKeyboardEvent_COMMA
    MINUS = _coin.SoKeyboardEvent_MINUS
    PERIOD = _coin.SoKeyboardEvent_PERIOD
    SLASH = _coin.SoKeyboardEvent_SLASH
    SEMICOLON = _coin.SoKeyboardEvent_SEMICOLON
    EQUAL = _coin.SoKeyboardEvent_EQUAL
    BRACKETLEFT = _coin.SoKeyboardEvent_BRACKETLEFT
    BACKSLASH = _coin.SoKeyboardEvent_BACKSLASH
    BRACKETRIGHT = _coin.SoKeyboardEvent_BRACKETRIGHT
    GRAVE = _coin.SoKeyboardEvent_GRAVE
    def setKey(self, *args):
        """setKey(self, Key key)"""
        return _coin.SoKeyboardEvent_setKey(self, *args)

    def getKey(self):
        """getKey(self) -> Key"""
        return _coin.SoKeyboardEvent_getKey(self)

    def setPrintableCharacter(self, *args):
        """setPrintableCharacter(self, char c)"""
        return _coin.SoKeyboardEvent_setPrintableCharacter(self, *args)

    def getPrintableCharacter(self):
        """getPrintableCharacter(self) -> char"""
        return _coin.SoKeyboardEvent_getPrintableCharacter(self)

    def isKeyPressEvent(*args):
        """isKeyPressEvent(SoEvent e, Key whichKey) -> SbBool"""
        return _coin.SoKeyboardEvent_isKeyPressEvent(*args)

    isKeyPressEvent = staticmethod(isKeyPressEvent)
    def isKeyReleaseEvent(*args):
        """isKeyReleaseEvent(SoEvent e, Key whichKey) -> SbBool"""
        return _coin.SoKeyboardEvent_isKeyReleaseEvent(*args)

    isKeyReleaseEvent = staticmethod(isKeyReleaseEvent)
    def enumToString(*args):
        """enumToString(Key enumval, SbString stringrep) -> SbBool"""
        return _coin.SoKeyboardEvent_enumToString(*args)

    enumToString = staticmethod(enumToString)
SoKeyboardEvent_swigregister = _coin.SoKeyboardEvent_swigregister
SoKeyboardEvent_swigregister(SoKeyboardEvent)

def SoKeyboardEvent_getClassTypeId():
  """SoKeyboardEvent_getClassTypeId() -> SoType"""
  return _coin.SoKeyboardEvent_getClassTypeId()

def SoKeyboardEvent_initClass():
  """SoKeyboardEvent_initClass()"""
  return _coin.SoKeyboardEvent_initClass()

def SoKeyboardEvent_isKeyPressEvent(*args):
  """SoKeyboardEvent_isKeyPressEvent(SoEvent e, Key whichKey) -> SbBool"""
  return _coin.SoKeyboardEvent_isKeyPressEvent(*args)

def SoKeyboardEvent_isKeyReleaseEvent(*args):
  """SoKeyboardEvent_isKeyReleaseEvent(SoEvent e, Key whichKey) -> SbBool"""
  return _coin.SoKeyboardEvent_isKeyReleaseEvent(*args)

def SoKeyboardEvent_enumToString(*args):
  """SoKeyboardEvent_enumToString(Key enumval, SbString stringrep) -> SbBool"""
  return _coin.SoKeyboardEvent_enumToString(*args)

class SoMouseButtonEvent(SoButtonEvent):
    """Proxy of C++ SoMouseButtonEvent class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMouseButtonEvent_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMouseButtonEvent_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoMouseButtonEvent_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoMouseButtonEvent"""
        this = _coin.new_SoMouseButtonEvent()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMouseButtonEvent
    __del__ = lambda self : None;
    ANY = _coin.SoMouseButtonEvent_ANY
    BUTTON1 = _coin.SoMouseButtonEvent_BUTTON1
    BUTTON2 = _coin.SoMouseButtonEvent_BUTTON2
    BUTTON3 = _coin.SoMouseButtonEvent_BUTTON3
    BUTTON4 = _coin.SoMouseButtonEvent_BUTTON4
    BUTTON5 = _coin.SoMouseButtonEvent_BUTTON5
    def setButton(self, *args):
        """setButton(self, Button button)"""
        return _coin.SoMouseButtonEvent_setButton(self, *args)

    def getButton(self):
        """getButton(self) -> Button"""
        return _coin.SoMouseButtonEvent_getButton(self)

    def isButtonPressEvent(*args):
        """isButtonPressEvent(SoEvent e, Button whichButton) -> SbBool"""
        return _coin.SoMouseButtonEvent_isButtonPressEvent(*args)

    isButtonPressEvent = staticmethod(isButtonPressEvent)
    def isButtonReleaseEvent(*args):
        """isButtonReleaseEvent(SoEvent e, Button whichButton) -> SbBool"""
        return _coin.SoMouseButtonEvent_isButtonReleaseEvent(*args)

    isButtonReleaseEvent = staticmethod(isButtonReleaseEvent)
    def enumToString(*args):
        """enumToString(Button enumval, SbString stringrep) -> SbBool"""
        return _coin.SoMouseButtonEvent_enumToString(*args)

    enumToString = staticmethod(enumToString)
SoMouseButtonEvent_swigregister = _coin.SoMouseButtonEvent_swigregister
SoMouseButtonEvent_swigregister(SoMouseButtonEvent)

def SoMouseButtonEvent_getClassTypeId():
  """SoMouseButtonEvent_getClassTypeId() -> SoType"""
  return _coin.SoMouseButtonEvent_getClassTypeId()

def SoMouseButtonEvent_initClass():
  """SoMouseButtonEvent_initClass()"""
  return _coin.SoMouseButtonEvent_initClass()

def SoMouseButtonEvent_isButtonPressEvent(*args):
  """SoMouseButtonEvent_isButtonPressEvent(SoEvent e, Button whichButton) -> SbBool"""
  return _coin.SoMouseButtonEvent_isButtonPressEvent(*args)

def SoMouseButtonEvent_isButtonReleaseEvent(*args):
  """SoMouseButtonEvent_isButtonReleaseEvent(SoEvent e, Button whichButton) -> SbBool"""
  return _coin.SoMouseButtonEvent_isButtonReleaseEvent(*args)

def SoMouseButtonEvent_enumToString(*args):
  """SoMouseButtonEvent_enumToString(Button enumval, SbString stringrep) -> SbBool"""
  return _coin.SoMouseButtonEvent_enumToString(*args)

class SoSpaceballButtonEvent(SoButtonEvent):
    """Proxy of C++ SoSpaceballButtonEvent class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSpaceballButtonEvent_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSpaceballButtonEvent_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoSpaceballButtonEvent_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoSpaceballButtonEvent"""
        this = _coin.new_SoSpaceballButtonEvent()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSpaceballButtonEvent
    __del__ = lambda self : None;
    ANY = _coin.SoSpaceballButtonEvent_ANY
    BUTTON1 = _coin.SoSpaceballButtonEvent_BUTTON1
    BUTTON2 = _coin.SoSpaceballButtonEvent_BUTTON2
    BUTTON3 = _coin.SoSpaceballButtonEvent_BUTTON3
    BUTTON4 = _coin.SoSpaceballButtonEvent_BUTTON4
    BUTTON5 = _coin.SoSpaceballButtonEvent_BUTTON5
    BUTTON6 = _coin.SoSpaceballButtonEvent_BUTTON6
    BUTTON7 = _coin.SoSpaceballButtonEvent_BUTTON7
    BUTTON8 = _coin.SoSpaceballButtonEvent_BUTTON8
    PICK = _coin.SoSpaceballButtonEvent_PICK
    def setButton(self, *args):
        """setButton(self, Button button)"""
        return _coin.SoSpaceballButtonEvent_setButton(self, *args)

    def getButton(self):
        """getButton(self) -> Button"""
        return _coin.SoSpaceballButtonEvent_getButton(self)

    def isButtonPressEvent(*args):
        """isButtonPressEvent(SoEvent e, Button whichButton) -> SbBool"""
        return _coin.SoSpaceballButtonEvent_isButtonPressEvent(*args)

    isButtonPressEvent = staticmethod(isButtonPressEvent)
    def isButtonReleaseEvent(*args):
        """isButtonReleaseEvent(SoEvent e, Button whichButton) -> SbBool"""
        return _coin.SoSpaceballButtonEvent_isButtonReleaseEvent(*args)

    isButtonReleaseEvent = staticmethod(isButtonReleaseEvent)
    def enumToString(*args):
        """enumToString(Button enumval, SbString stringrep) -> SbBool"""
        return _coin.SoSpaceballButtonEvent_enumToString(*args)

    enumToString = staticmethod(enumToString)
SoSpaceballButtonEvent_swigregister = _coin.SoSpaceballButtonEvent_swigregister
SoSpaceballButtonEvent_swigregister(SoSpaceballButtonEvent)

def SoSpaceballButtonEvent_getClassTypeId():
  """SoSpaceballButtonEvent_getClassTypeId() -> SoType"""
  return _coin.SoSpaceballButtonEvent_getClassTypeId()

def SoSpaceballButtonEvent_initClass():
  """SoSpaceballButtonEvent_initClass()"""
  return _coin.SoSpaceballButtonEvent_initClass()

def SoSpaceballButtonEvent_isButtonPressEvent(*args):
  """SoSpaceballButtonEvent_isButtonPressEvent(SoEvent e, Button whichButton) -> SbBool"""
  return _coin.SoSpaceballButtonEvent_isButtonPressEvent(*args)

def SoSpaceballButtonEvent_isButtonReleaseEvent(*args):
  """SoSpaceballButtonEvent_isButtonReleaseEvent(SoEvent e, Button whichButton) -> SbBool"""
  return _coin.SoSpaceballButtonEvent_isButtonReleaseEvent(*args)

def SoSpaceballButtonEvent_enumToString(*args):
  """SoSpaceballButtonEvent_enumToString(Button enumval, SbString stringrep) -> SbBool"""
  return _coin.SoSpaceballButtonEvent_enumToString(*args)

class SbBox2s(object):
    """Proxy of C++ SbBox2s class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbBox2s
        __init__(self, short xmin, short ymin, short xmax, short ymax) -> SbBox2s
        __init__(self, SbVec2s minpoint, SbVec2s maxpoint) -> SbBox2s
        __init__(self, SbBox2i32 box) -> SbBox2s
        __init__(self, SbBox2f box) -> SbBox2s
        __init__(self, SbBox2d box) -> SbBox2s
        """
        this = _coin.new_SbBox2s(*args)
        try: self.this.append(this)
        except: self.this = this
    def setBounds(self, *args):
        """
        setBounds(self, short xmin, short ymin, short xmax, short ymax) -> SbBox2s
        setBounds(self, SbVec2s minpoint, SbVec2s maxpoint) -> SbBox2s
        setBounds(self, SbBox2i32 box) -> SbBox2s
        setBounds(self, SbBox2f box) -> SbBox2s
        setBounds(self, SbBox2d box) -> SbBox2s
        """
        return _coin.SbBox2s_setBounds(self, *args)

    def getBounds(self, *args):
        """
        getBounds(self, short xmin, short ymin, short xmax, short ymax)
        getBounds(self, SbVec2s minpoint, SbVec2s maxpoint)
        """
        return _coin.SbBox2s_getBounds(self, *args)

    def getMin(self, *args):
        """
        getMin(self) -> SbVec2s
        getMin(self) -> SbVec2s
        """
        return _coin.SbBox2s_getMin(self, *args)

    def getMax(self, *args):
        """
        getMax(self) -> SbVec2s
        getMax(self) -> SbVec2s
        """
        return _coin.SbBox2s_getMax(self, *args)

    def extendBy(self, *args):
        """
        extendBy(self, SbVec2s point)
        extendBy(self, SbBox2s box)
        """
        return _coin.SbBox2s_extendBy(self, *args)

    def makeEmpty(self):
        """makeEmpty(self)"""
        return _coin.SbBox2s_makeEmpty(self)

    def isEmpty(self):
        """isEmpty(self) -> SbBool"""
        return _coin.SbBox2s_isEmpty(self)

    def hasArea(self):
        """hasArea(self) -> SbBool"""
        return _coin.SbBox2s_hasArea(self)

    def intersect(self, *args):
        """
        intersect(self, SbVec2s point) -> SbBool
        intersect(self, SbBox2s box) -> SbBool
        """
        return _coin.SbBox2s_intersect(self, *args)

    def getCenter(self):
        """getCenter(self) -> SbVec2f"""
        return _coin.SbBox2s_getCenter(self)

    def getOrigin(self, *args):
        """getOrigin(self, short originX, short originY)"""
        return _coin.SbBox2s_getOrigin(self, *args)

    def getSize(self, *args):
        """getSize(self, short sizeX, short sizeY)"""
        return _coin.SbBox2s_getSize(self, *args)

    def getAspectRatio(self):
        """getAspectRatio(self) -> float"""
        return _coin.SbBox2s_getAspectRatio(self)

    def __eq__(self, *args):
        """__eq__(self, SbBox2s u) -> int"""
        return _coin.SbBox2s___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SbBox2s u) -> int"""
        return _coin.SbBox2s___ne__(self, *args)

    __swig_destroy__ = _coin.delete_SbBox2s
    __del__ = lambda self : None;
SbBox2s_swigregister = _coin.SbBox2s_swigregister
SbBox2s_swigregister(SbBox2s)

class SoSFBox2s(SoSField):
    """Proxy of C++ SoSFBox2s class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFBox2s"""
        this = _coin.new_SoSFBox2s()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFBox2s
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFBox2s_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFBox2s_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFBox2s_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFBox2s_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFBox2s_isSame(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoSFBox2s field) -> int"""
        return _coin.SoSFBox2s___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFBox2s field) -> int"""
        return _coin.SoSFBox2s___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFBox2s_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbBox2s newvalue)
        setValue(self, short xmin, short ymin, short xmax, short ymax)
        setValue(self, SbVec2s minvec, SbVec2s maxvec)
        """
        return _coin.SoSFBox2s_setValue(self, *args)

    def getValue(self, *args):
        """
        getValue(self) -> SbBox2s
        getValue(self, SbBox2s box)
        """
        return _coin.SoSFBox2s_getValue(self, *args)

SoSFBox2s_swigregister = _coin.SoSFBox2s_swigregister
SoSFBox2s_swigregister(SoSFBox2s)

def SoSFBox2s_createInstance():
  """SoSFBox2s_createInstance() -> void"""
  return _coin.SoSFBox2s_createInstance()

def SoSFBox2s_getClassTypeId():
  """SoSFBox2s_getClassTypeId() -> SoType"""
  return _coin.SoSFBox2s_getClassTypeId()

def SoSFBox2s_initClass():
  """SoSFBox2s_initClass()"""
  return _coin.SoSFBox2s_initClass()

class SbVec2i32(object):
    """Proxy of C++ SbVec2i32 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbVec2i32
        __init__(self, int32_t v) -> SbVec2i32
        __init__(self, int32_t x, int32_t y) -> SbVec2i32
        __init__(self, SbVec2ui32 v) -> SbVec2i32
        __init__(self, SbVec2b v) -> SbVec2i32
        __init__(self, SbVec2s v) -> SbVec2i32
        __init__(self, SbVec2f v) -> SbVec2i32
        __init__(self, SbVec2d v) -> SbVec2i32
        """
        this = _coin.new_SbVec2i32(*args)
        try: self.this.append(this)
        except: self.this = this
    def setValue(self, *args):
        """
        setValue(self, int32_t v) -> SbVec2i32
        setValue(self, int32_t x, int32_t y) -> SbVec2i32
        setValue(self, SbVec2ui32 v) -> SbVec2i32
        setValue(self, SbVec2b v) -> SbVec2i32
        setValue(self, SbVec2s v) -> SbVec2i32
        setValue(self, SbVec2f v) -> SbVec2i32
        setValue(self, SbVec2d v) -> SbVec2i32
        """
        return _coin.SbVec2i32_setValue(self, *args)

    def getValue(self, *args):
        """
        getValue(self) -> int32_t
        getValue(self, int32_t x, int32_t y)
        """
        return _coin.SbVec2i32_getValue(self, *args)

    def dot(self, *args):
        """dot(self, SbVec2i32 v) -> int32_t"""
        return _coin.SbVec2i32_dot(self, *args)

    def negate(self):
        """negate(self)"""
        return _coin.SbVec2i32_negate(self)

    def __imul__(self, *args):
        """
        __imul__(self, int d) -> SbVec2i32
        __imul__(self, double d) -> SbVec2i32
        """
        return _coin.SbVec2i32___imul__(self, *args)

    def __idiv__(self, *args):
        """
        __idiv__(self, int d) -> SbVec2i32
        __idiv__(self, double d) -> SbVec2i32
        """
        return _coin.SbVec2i32___idiv__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, SbVec2i32 v) -> SbVec2i32"""
        return _coin.SbVec2i32___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, SbVec2i32 v) -> SbVec2i32"""
        return _coin.SbVec2i32___isub__(self, *args)

    def __neg__(self):
        """__neg__(self) -> SbVec2i32"""
        return _coin.SbVec2i32___neg__(self)

    def output(self, *args):
        """output(self, FILE fp)"""
        return _coin.SbVec2i32_output(self, *args)

    __swig_destroy__ = _coin.delete_SbVec2i32
    __del__ = lambda self : None;
SbVec2i32_swigregister = _coin.SbVec2i32_swigregister
SbVec2i32_swigregister(SbVec2i32)

class SbBox2i32(object):
    """Proxy of C++ SbBox2i32 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbBox2i32
        __init__(self, int32_t xmin, int32_t ymin, int32_t xmax, int32_t ymax) -> SbBox2i32
        __init__(self, SbVec2i32 minpoint, SbVec2i32 maxpoint) -> SbBox2i32
        __init__(self, SbBox2s box) -> SbBox2i32
        __init__(self, SbBox2f box) -> SbBox2i32
        __init__(self, SbBox2d box) -> SbBox2i32
        """
        this = _coin.new_SbBox2i32(*args)
        try: self.this.append(this)
        except: self.this = this
    def setBounds(self, *args):
        """
        setBounds(self, int32_t xmin, int32_t ymin, int32_t xmax, int32_t ymax) -> SbBox2i32
        setBounds(self, SbVec2i32 minpoint, SbVec2i32 maxpoint) -> SbBox2i32
        setBounds(self, SbBox2s box) -> SbBox2i32
        setBounds(self, SbBox2f box) -> SbBox2i32
        setBounds(self, SbBox2d box) -> SbBox2i32
        """
        return _coin.SbBox2i32_setBounds(self, *args)

    def getBounds(self, *args):
        """
        getBounds(self, int32_t xmin, int32_t ymin, int32_t xmax, int32_t ymax)
        getBounds(self, SbVec2i32 minpoint, SbVec2i32 maxpoint)
        """
        return _coin.SbBox2i32_getBounds(self, *args)

    def getMin(self, *args):
        """
        getMin(self) -> SbVec2i32
        getMin(self) -> SbVec2i32
        """
        return _coin.SbBox2i32_getMin(self, *args)

    def getMax(self, *args):
        """
        getMax(self) -> SbVec2i32
        getMax(self) -> SbVec2i32
        """
        return _coin.SbBox2i32_getMax(self, *args)

    def extendBy(self, *args):
        """
        extendBy(self, SbVec2i32 point)
        extendBy(self, SbBox2i32 box)
        """
        return _coin.SbBox2i32_extendBy(self, *args)

    def makeEmpty(self):
        """makeEmpty(self)"""
        return _coin.SbBox2i32_makeEmpty(self)

    def isEmpty(self):
        """isEmpty(self) -> SbBool"""
        return _coin.SbBox2i32_isEmpty(self)

    def hasArea(self):
        """hasArea(self) -> SbBool"""
        return _coin.SbBox2i32_hasArea(self)

    def intersect(self, *args):
        """
        intersect(self, SbVec2i32 point) -> SbBool
        intersect(self, SbBox2i32 box) -> SbBool
        """
        return _coin.SbBox2i32_intersect(self, *args)

    def getCenter(self):
        """getCenter(self) -> SbVec2f"""
        return _coin.SbBox2i32_getCenter(self)

    def getOrigin(self, *args):
        """getOrigin(self, int32_t originX, int32_t originY)"""
        return _coin.SbBox2i32_getOrigin(self, *args)

    def getSize(self, *args):
        """getSize(self, int32_t sizeX, int32_t sizeY)"""
        return _coin.SbBox2i32_getSize(self, *args)

    def getAspectRatio(self):
        """getAspectRatio(self) -> float"""
        return _coin.SbBox2i32_getAspectRatio(self)

    __swig_destroy__ = _coin.delete_SbBox2i32
    __del__ = lambda self : None;
SbBox2i32_swigregister = _coin.SbBox2i32_swigregister
SbBox2i32_swigregister(SbBox2i32)

class SoSFBox2i32(SoSField):
    """Proxy of C++ SoSFBox2i32 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFBox2i32"""
        this = _coin.new_SoSFBox2i32()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFBox2i32
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFBox2i32_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFBox2i32_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFBox2i32_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFBox2i32_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFBox2i32_isSame(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoSFBox2i32 field) -> int"""
        return _coin.SoSFBox2i32___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFBox2i32 field) -> int"""
        return _coin.SoSFBox2i32___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFBox2i32_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbBox2i32 newvalue)
        setValue(self, int32_t xmin, int32_t ymin, int32_t xmax, int32_t ymax)
        setValue(self, SbVec2i32 minvec, SbVec2i32 maxvec)
        """
        return _coin.SoSFBox2i32_setValue(self, *args)

    def getValue(self, *args):
        """
        getValue(self) -> SbBox2i32
        getValue(self, SbBox2i32 box)
        """
        return _coin.SoSFBox2i32_getValue(self, *args)

SoSFBox2i32_swigregister = _coin.SoSFBox2i32_swigregister
SoSFBox2i32_swigregister(SoSFBox2i32)

def SoSFBox2i32_createInstance():
  """SoSFBox2i32_createInstance() -> void"""
  return _coin.SoSFBox2i32_createInstance()

def SoSFBox2i32_getClassTypeId():
  """SoSFBox2i32_getClassTypeId() -> SoType"""
  return _coin.SoSFBox2i32_getClassTypeId()

def SoSFBox2i32_initClass():
  """SoSFBox2i32_initClass()"""
  return _coin.SoSFBox2i32_initClass()

class SbBox2f(object):
    """Proxy of C++ SbBox2f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbBox2f
        __init__(self, float xmin, float ymin, float xmax, float ymax) -> SbBox2f
        __init__(self, SbVec2f minpoint, SbVec2f maxpoint) -> SbBox2f
        __init__(self, SbBox2d box) -> SbBox2f
        __init__(self, SbBox2s box) -> SbBox2f
        __init__(self, SbBox2i32 box) -> SbBox2f
        """
        this = _coin.new_SbBox2f(*args)
        try: self.this.append(this)
        except: self.this = this
    def setBounds(self, *args):
        """
        setBounds(self, float xmin, float ymin, float xmax, float ymax) -> SbBox2f
        setBounds(self, SbVec2f minpoint, SbVec2f maxpoint) -> SbBox2f
        setBounds(self, SbBox2d box) -> SbBox2f
        setBounds(self, SbBox2s box) -> SbBox2f
        setBounds(self, SbBox2i32 box) -> SbBox2f
        """
        return _coin.SbBox2f_setBounds(self, *args)

    def getBounds(self, *args):
        """
        getBounds(self, float xmin, float ymin, float xmax, float ymax)
        getBounds(self, SbVec2f minpoint, SbVec2f maxpoint)
        """
        return _coin.SbBox2f_getBounds(self, *args)

    def getMin(self, *args):
        """
        getMin(self) -> SbVec2f
        getMin(self) -> SbVec2f
        """
        return _coin.SbBox2f_getMin(self, *args)

    def getMax(self, *args):
        """
        getMax(self) -> SbVec2f
        getMax(self) -> SbVec2f
        """
        return _coin.SbBox2f_getMax(self, *args)

    def extendBy(self, *args):
        """
        extendBy(self, SbVec2f point)
        extendBy(self, SbBox2f box)
        """
        return _coin.SbBox2f_extendBy(self, *args)

    def makeEmpty(self):
        """makeEmpty(self)"""
        return _coin.SbBox2f_makeEmpty(self)

    def isEmpty(self):
        """isEmpty(self) -> SbBool"""
        return _coin.SbBox2f_isEmpty(self)

    def hasArea(self):
        """hasArea(self) -> SbBool"""
        return _coin.SbBox2f_hasArea(self)

    def intersect(self, *args):
        """
        intersect(self, SbVec2f point) -> SbBool
        intersect(self, SbBox2f box) -> SbBool
        """
        return _coin.SbBox2f_intersect(self, *args)

    def getClosestPoint(self, *args):
        """getClosestPoint(self, SbVec2f point) -> SbVec2f"""
        return _coin.SbBox2f_getClosestPoint(self, *args)

    def getCenter(self):
        """getCenter(self) -> SbVec2f"""
        return _coin.SbBox2f_getCenter(self)

    def getOrigin(self, *args):
        """getOrigin(self, float originX, float originY)"""
        return _coin.SbBox2f_getOrigin(self, *args)

    def getSize(self, *args):
        """getSize(self, float sizeX, float sizeY)"""
        return _coin.SbBox2f_getSize(self, *args)

    def getAspectRatio(self):
        """getAspectRatio(self) -> float"""
        return _coin.SbBox2f_getAspectRatio(self)

    def __eq__(self, *args):
        """__eq__(self, SbBox2f u) -> int"""
        return _coin.SbBox2f___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SbBox2f u) -> int"""
        return _coin.SbBox2f___ne__(self, *args)

    __swig_destroy__ = _coin.delete_SbBox2f
    __del__ = lambda self : None;
SbBox2f_swigregister = _coin.SbBox2f_swigregister
SbBox2f_swigregister(SbBox2f)

class SoSFBox2f(SoSField):
    """Proxy of C++ SoSFBox2f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFBox2f"""
        this = _coin.new_SoSFBox2f()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFBox2f
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFBox2f_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFBox2f_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFBox2f_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFBox2f_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFBox2f_isSame(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoSFBox2f field) -> int"""
        return _coin.SoSFBox2f___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFBox2f field) -> int"""
        return _coin.SoSFBox2f___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFBox2f_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbBox2f newvalue)
        setValue(self, float xmin, float ymin, float xmax, float ymax)
        setValue(self, SbVec2f minvec, SbVec2f maxvec)
        """
        return _coin.SoSFBox2f_setValue(self, *args)

    def getValue(self, *args):
        """
        getValue(self) -> SbBox2f
        getValue(self, SbBox2f box)
        """
        return _coin.SoSFBox2f_getValue(self, *args)

SoSFBox2f_swigregister = _coin.SoSFBox2f_swigregister
SoSFBox2f_swigregister(SoSFBox2f)

def SoSFBox2f_createInstance():
  """SoSFBox2f_createInstance() -> void"""
  return _coin.SoSFBox2f_createInstance()

def SoSFBox2f_getClassTypeId():
  """SoSFBox2f_getClassTypeId() -> SoType"""
  return _coin.SoSFBox2f_getClassTypeId()

def SoSFBox2f_initClass():
  """SoSFBox2f_initClass()"""
  return _coin.SoSFBox2f_initClass()

class SbVec2d(object):
    """Proxy of C++ SbVec2d class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbVec2d
        __init__(self, double v) -> SbVec2d
        __init__(self, double x, double y) -> SbVec2d
        __init__(self, SbVec2f v) -> SbVec2d
        __init__(self, SbVec2b v) -> SbVec2d
        __init__(self, SbVec2s v) -> SbVec2d
        __init__(self, SbVec2i32 v) -> SbVec2d
        """
        this = _coin.new_SbVec2d(*args)
        try: self.this.append(this)
        except: self.this = this
    def setValue(self, *args):
        """
        setValue(self, double v) -> SbVec2d
        setValue(self, double x, double y) -> SbVec2d
        setValue(self, SbVec2f v) -> SbVec2d
        setValue(self, SbVec2b v) -> SbVec2d
        setValue(self, SbVec2s v) -> SbVec2d
        setValue(self, SbVec2i32 v) -> SbVec2d
        """
        return _coin.SbVec2d_setValue(self, *args)

    def getValue(self):
        """getValue(self)"""
        return _coin.SbVec2d_getValue(self)

    def equals(self, *args):
        """equals(self, SbVec2d v, double tolerance) -> SbBool"""
        return _coin.SbVec2d_equals(self, *args)

    def dot(self, *args):
        """dot(self, SbVec2d v) -> double"""
        return _coin.SbVec2d_dot(self, *args)

    def length(self):
        """length(self) -> double"""
        return _coin.SbVec2d_length(self)

    def sqrLength(self):
        """sqrLength(self) -> double"""
        return _coin.SbVec2d_sqrLength(self)

    def normalize(self):
        """normalize(self) -> double"""
        return _coin.SbVec2d_normalize(self)

    def negate(self):
        """negate(self)"""
        return _coin.SbVec2d_negate(self)

    def __imul__(self, *args):
        """__imul__(self, double d) -> SbVec2d"""
        return _coin.SbVec2d___imul__(self, *args)

    def __idiv__(self, *args):
        """__idiv__(self, double d) -> SbVec2d"""
        return _coin.SbVec2d___idiv__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, SbVec2d v) -> SbVec2d"""
        return _coin.SbVec2d___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, SbVec2d v) -> SbVec2d"""
        return _coin.SbVec2d___isub__(self, *args)

    def __neg__(self):
        """__neg__(self) -> SbVec2d"""
        return _coin.SbVec2d___neg__(self)

    def output(self, *args):
        """output(self, FILE fp)"""
        return _coin.SbVec2d_output(self, *args)

    def __add__(self, *args):
        """__add__(self, SbVec2d u) -> SbVec2d"""
        return _coin.SbVec2d___add__(self, *args)

    def __sub__(self, *args):
        """__sub__(self, SbVec2d u) -> SbVec2d"""
        return _coin.SbVec2d___sub__(self, *args)

    def __mul__(self, *args):
        """__mul__(self, float d) -> SbVec2d"""
        return _coin.SbVec2d___mul__(self, *args)

    def __rmul__(self, *args):
        """__rmul__(self, float d) -> SbVec2d"""
        return _coin.SbVec2d___rmul__(self, *args)

    def __div__(self, *args):
        """__div__(self, float d) -> SbVec2d"""
        return _coin.SbVec2d___div__(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SbVec2d u) -> int"""
        return _coin.SbVec2d___eq__(self, *args)

    def __nq__(self, *args):
        """__nq__(self, SbVec2d u) -> int"""
        return _coin.SbVec2d___nq__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> double"""
        return _coin.SbVec2d___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, double value)"""
        return _coin.SbVec2d___setitem__(self, *args)

    def __iter__(self):
       for i in range(2):
          yield self[i]

    def __len__(self):
          return 2

    __swig_destroy__ = _coin.delete_SbVec2d
    __del__ = lambda self : None;
SbVec2d_swigregister = _coin.SbVec2d_swigregister
SbVec2d_swigregister(SbVec2d)

class SbBox2d(object):
    """Proxy of C++ SbBox2d class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbBox2d
        __init__(self, double xmin, double ymin, double xmax, double ymax) -> SbBox2d
        __init__(self, SbVec2d minpoint, SbVec2d maxpoint) -> SbBox2d
        __init__(self, SbBox2f box) -> SbBox2d
        __init__(self, SbBox2s box) -> SbBox2d
        __init__(self, SbBox2i32 box) -> SbBox2d
        """
        this = _coin.new_SbBox2d(*args)
        try: self.this.append(this)
        except: self.this = this
    def setBounds(self, *args):
        """
        setBounds(self, double xmin, double ymin, double xmax, double ymax) -> SbBox2d
        setBounds(self, SbVec2d minpoint, SbVec2d maxpoint) -> SbBox2d
        setBounds(self, SbBox2f box) -> SbBox2d
        setBounds(self, SbBox2s box) -> SbBox2d
        setBounds(self, SbBox2i32 box) -> SbBox2d
        """
        return _coin.SbBox2d_setBounds(self, *args)

    def getBounds(self, *args):
        """
        getBounds(self, double xmin, double ymin, double xmax, double ymax)
        getBounds(self, SbVec2d minpoint, SbVec2d maxpoint)
        """
        return _coin.SbBox2d_getBounds(self, *args)

    def getMin(self, *args):
        """
        getMin(self) -> SbVec2d
        getMin(self) -> SbVec2d
        """
        return _coin.SbBox2d_getMin(self, *args)

    def getMax(self, *args):
        """
        getMax(self) -> SbVec2d
        getMax(self) -> SbVec2d
        """
        return _coin.SbBox2d_getMax(self, *args)

    def extendBy(self, *args):
        """
        extendBy(self, SbVec2d point)
        extendBy(self, SbBox2d box)
        """
        return _coin.SbBox2d_extendBy(self, *args)

    def makeEmpty(self):
        """makeEmpty(self)"""
        return _coin.SbBox2d_makeEmpty(self)

    def isEmpty(self):
        """isEmpty(self) -> SbBool"""
        return _coin.SbBox2d_isEmpty(self)

    def hasArea(self):
        """hasArea(self) -> SbBool"""
        return _coin.SbBox2d_hasArea(self)

    def intersect(self, *args):
        """
        intersect(self, SbVec2d point) -> SbBool
        intersect(self, SbBox2d box) -> SbBool
        """
        return _coin.SbBox2d_intersect(self, *args)

    def getClosestPoint(self, *args):
        """getClosestPoint(self, SbVec2d p) -> SbVec2d"""
        return _coin.SbBox2d_getClosestPoint(self, *args)

    def findIntersection(self, *args):
        """findIntersection(self, SbVec2d a, SbVec2d b, SbVec2d ia, SbVec2d ib) -> SbBool"""
        return _coin.SbBox2d_findIntersection(self, *args)

    def getCenter(self):
        """getCenter(self) -> SbVec2d"""
        return _coin.SbBox2d_getCenter(self)

    def getOrigin(self, *args):
        """getOrigin(self, double originX, double originY)"""
        return _coin.SbBox2d_getOrigin(self, *args)

    def getSize(self, *args):
        """getSize(self, double sizeX, double sizeY)"""
        return _coin.SbBox2d_getSize(self, *args)

    def getAspectRatio(self):
        """getAspectRatio(self) -> double"""
        return _coin.SbBox2d_getAspectRatio(self)

    def __eq__(self, *args):
        """__eq__(self, SbBox2d u) -> int"""
        return _coin.SbBox2d___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SbBox2d u) -> int"""
        return _coin.SbBox2d___ne__(self, *args)

    def setValue(self, *args):
        """setValue(self, SbBox2d u) -> SbBox2d"""
        return _coin.SbBox2d_setValue(self, *args)

    __swig_destroy__ = _coin.delete_SbBox2d
    __del__ = lambda self : None;
SbBox2d_swigregister = _coin.SbBox2d_swigregister
SbBox2d_swigregister(SbBox2d)

class SoSFBox2d(SoSField):
    """Proxy of C++ SoSFBox2d class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFBox2d"""
        this = _coin.new_SoSFBox2d()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFBox2d
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFBox2d_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFBox2d_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFBox2d_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFBox2d_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFBox2d_isSame(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoSFBox2d field) -> int"""
        return _coin.SoSFBox2d___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFBox2d field) -> int"""
        return _coin.SoSFBox2d___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFBox2d_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbBox2d newvalue)
        setValue(self, double xmin, double ymin, double xmax, double ymax)
        setValue(self, SbVec2d minvec, SbVec2d maxvec)
        """
        return _coin.SoSFBox2d_setValue(self, *args)

    def getValue(self, *args):
        """
        getValue(self) -> SbBox2d
        getValue(self, SbBox2d box)
        """
        return _coin.SoSFBox2d_getValue(self, *args)

SoSFBox2d_swigregister = _coin.SoSFBox2d_swigregister
SoSFBox2d_swigregister(SoSFBox2d)

def SoSFBox2d_createInstance():
  """SoSFBox2d_createInstance() -> void"""
  return _coin.SoSFBox2d_createInstance()

def SoSFBox2d_getClassTypeId():
  """SoSFBox2d_getClassTypeId() -> SoType"""
  return _coin.SoSFBox2d_getClassTypeId()

def SoSFBox2d_initClass():
  """SoSFBox2d_initClass()"""
  return _coin.SoSFBox2d_initClass()

class SbBox3s(object):
    """Proxy of C++ SbBox3s class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbBox3s
        __init__(self, short xmin, short ymin, short zmin, short xmax, short ymax, 
            short zmax) -> SbBox3s
        __init__(self, SbVec3s minpoint, SbVec3s maxpoint) -> SbBox3s
        __init__(self, SbBox3i32 box) -> SbBox3s
        __init__(self, SbBox3f box) -> SbBox3s
        __init__(self, SbBox3d box) -> SbBox3s
        """
        this = _coin.new_SbBox3s(*args)
        try: self.this.append(this)
        except: self.this = this
    def setBounds(self, *args):
        """
        setBounds(self, short xmin, short ymin, short zmin, short xmax, short ymax, 
            short zmax) -> SbBox3s
        setBounds(self, SbVec3s minpoint, SbVec3s maxpoint) -> SbBox3s
        setBounds(self, SbBox3i32 box) -> SbBox3s
        setBounds(self, SbBox3f box) -> SbBox3s
        setBounds(self, SbBox3d box) -> SbBox3s
        """
        return _coin.SbBox3s_setBounds(self, *args)

    def getBounds(self, *args):
        """
        getBounds(self, short xmin, short ymin, short zmin, short xmax, short ymax, 
            short zmax)
        getBounds(self, SbVec3s minpoint, SbVec3s maxpoint)
        """
        return _coin.SbBox3s_getBounds(self, *args)

    def getMin(self, *args):
        """
        getMin(self) -> SbVec3s
        getMin(self) -> SbVec3s
        """
        return _coin.SbBox3s_getMin(self, *args)

    def getMax(self, *args):
        """
        getMax(self) -> SbVec3s
        getMax(self) -> SbVec3s
        """
        return _coin.SbBox3s_getMax(self, *args)

    def extendBy(self, *args):
        """
        extendBy(self, SbVec3s pt)
        extendBy(self, SbBox3s box)
        """
        return _coin.SbBox3s_extendBy(self, *args)

    def makeEmpty(self):
        """makeEmpty(self)"""
        return _coin.SbBox3s_makeEmpty(self)

    def isEmpty(self):
        """isEmpty(self) -> SbBool"""
        return _coin.SbBox3s_isEmpty(self)

    def hasVolume(self):
        """hasVolume(self) -> SbBool"""
        return _coin.SbBox3s_hasVolume(self)

    def getVolume(self):
        """getVolume(self) -> int"""
        return _coin.SbBox3s_getVolume(self)

    def intersect(self, *args):
        """
        intersect(self, SbVec3s pt) -> SbBool
        intersect(self, SbBox3s box) -> SbBool
        """
        return _coin.SbBox3s_intersect(self, *args)

    def getClosestPoint(self, *args):
        """getClosestPoint(self, SbVec3f pt) -> SbVec3f"""
        return _coin.SbBox3s_getClosestPoint(self, *args)

    def getCenter(self):
        """getCenter(self) -> SbVec3f"""
        return _coin.SbBox3s_getCenter(self)

    def getOrigin(self, *args):
        """getOrigin(self, short originX, short originY, short originZ)"""
        return _coin.SbBox3s_getOrigin(self, *args)

    def getSize(self, *args):
        """getSize(self, short sizeX, short sizeY, short sizeZ)"""
        return _coin.SbBox3s_getSize(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SbBox3s u) -> int"""
        return _coin.SbBox3s___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SbBox3s u) -> int"""
        return _coin.SbBox3s___ne__(self, *args)

    __swig_destroy__ = _coin.delete_SbBox3s
    __del__ = lambda self : None;
SbBox3s_swigregister = _coin.SbBox3s_swigregister
SbBox3s_swigregister(SbBox3s)

class SoSFBox3s(SoSField):
    """Proxy of C++ SoSFBox3s class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFBox3s"""
        this = _coin.new_SoSFBox3s()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFBox3s
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFBox3s_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFBox3s_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFBox3s_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFBox3s_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFBox3s_isSame(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoSFBox3s field) -> int"""
        return _coin.SoSFBox3s___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFBox3s field) -> int"""
        return _coin.SoSFBox3s___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFBox3s_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbBox3s newvalue)
        setValue(self, short xmin, short ymin, short zmin, short xmax, short ymax, 
            short zmax)
        setValue(self, SbVec3s minvec, SbVec3s maxvec)
        """
        return _coin.SoSFBox3s_setValue(self, *args)

    def getValue(self, *args):
        """
        getValue(self) -> SbBox3s
        getValue(self, SbBox3s box)
        """
        return _coin.SoSFBox3s_getValue(self, *args)

SoSFBox3s_swigregister = _coin.SoSFBox3s_swigregister
SoSFBox3s_swigregister(SoSFBox3s)

def SoSFBox3s_createInstance():
  """SoSFBox3s_createInstance() -> void"""
  return _coin.SoSFBox3s_createInstance()

def SoSFBox3s_getClassTypeId():
  """SoSFBox3s_getClassTypeId() -> SoType"""
  return _coin.SoSFBox3s_getClassTypeId()

def SoSFBox3s_initClass():
  """SoSFBox3s_initClass()"""
  return _coin.SoSFBox3s_initClass()

class SbVec3i32(object):
    """Proxy of C++ SbVec3i32 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbVec3i32
        __init__(self, int32_t v) -> SbVec3i32
        __init__(self, int32_t x, int32_t y, int32_t z) -> SbVec3i32
        __init__(self, SbVec3ui32 v) -> SbVec3i32
        __init__(self, SbVec3b v) -> SbVec3i32
        __init__(self, SbVec3s v) -> SbVec3i32
        __init__(self, SbVec3f v) -> SbVec3i32
        __init__(self, SbVec3d v) -> SbVec3i32
        """
        this = _coin.new_SbVec3i32(*args)
        try: self.this.append(this)
        except: self.this = this
    def setValue(self, *args):
        """
        setValue(self, int32_t v) -> SbVec3i32
        setValue(self, int32_t x, int32_t y, int32_t z) -> SbVec3i32
        setValue(self, SbVec3ui32 v) -> SbVec3i32
        setValue(self, SbVec3b v) -> SbVec3i32
        setValue(self, SbVec3s v) -> SbVec3i32
        setValue(self, SbVec3f v) -> SbVec3i32
        setValue(self, SbVec3d v) -> SbVec3i32
        """
        return _coin.SbVec3i32_setValue(self, *args)

    def getValue(self, *args):
        """
        getValue(self) -> int32_t
        getValue(self, int32_t x, int32_t y, int32_t z)
        """
        return _coin.SbVec3i32_getValue(self, *args)

    def dot(self, *args):
        """dot(self, SbVec3i32 v) -> int32_t"""
        return _coin.SbVec3i32_dot(self, *args)

    def negate(self):
        """negate(self)"""
        return _coin.SbVec3i32_negate(self)

    def __imul__(self, *args):
        """
        __imul__(self, int d) -> SbVec3i32
        __imul__(self, double d) -> SbVec3i32
        """
        return _coin.SbVec3i32___imul__(self, *args)

    def __idiv__(self, *args):
        """
        __idiv__(self, int d) -> SbVec3i32
        __idiv__(self, double d) -> SbVec3i32
        """
        return _coin.SbVec3i32___idiv__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, SbVec3i32 v) -> SbVec3i32"""
        return _coin.SbVec3i32___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, SbVec3i32 v) -> SbVec3i32"""
        return _coin.SbVec3i32___isub__(self, *args)

    def __neg__(self):
        """__neg__(self) -> SbVec3i32"""
        return _coin.SbVec3i32___neg__(self)

    __swig_destroy__ = _coin.delete_SbVec3i32
    __del__ = lambda self : None;
SbVec3i32_swigregister = _coin.SbVec3i32_swigregister
SbVec3i32_swigregister(SbVec3i32)

class SbBox3i32(object):
    """Proxy of C++ SbBox3i32 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbBox3i32
        __init__(self, int32_t xmin, int32_t ymin, int32_t zmin, int32_t xmax, 
            int32_t ymax, int32_t zmax) -> SbBox3i32
        __init__(self, SbVec3i32 minpoint, SbVec3i32 maxpoint) -> SbBox3i32
        __init__(self, SbBox3s box) -> SbBox3i32
        __init__(self, SbBox3f box) -> SbBox3i32
        __init__(self, SbBox3d box) -> SbBox3i32
        """
        this = _coin.new_SbBox3i32(*args)
        try: self.this.append(this)
        except: self.this = this
    def setBounds(self, *args):
        """
        setBounds(self, int32_t xmin, int32_t ymin, int32_t zmin, int32_t xmax, 
            int32_t ymax, int32_t zmax) -> SbBox3i32
        setBounds(self, SbVec3i32 minpoint, SbVec3i32 maxpoint) -> SbBox3i32
        setBounds(self, SbBox3s box) -> SbBox3i32
        setBounds(self, SbBox3f box) -> SbBox3i32
        setBounds(self, SbBox3d box) -> SbBox3i32
        """
        return _coin.SbBox3i32_setBounds(self, *args)

    def getBounds(self, *args):
        """
        getBounds(self, int32_t xmin, int32_t ymin, int32_t zmin, int32_t xmax, 
            int32_t ymax, int32_t zmax)
        getBounds(self, SbVec3i32 minpoint, SbVec3i32 maxpoint)
        """
        return _coin.SbBox3i32_getBounds(self, *args)

    def getMin(self, *args):
        """
        getMin(self) -> SbVec3i32
        getMin(self) -> SbVec3i32
        """
        return _coin.SbBox3i32_getMin(self, *args)

    def getMax(self, *args):
        """
        getMax(self) -> SbVec3i32
        getMax(self) -> SbVec3i32
        """
        return _coin.SbBox3i32_getMax(self, *args)

    def extendBy(self, *args):
        """
        extendBy(self, SbVec3i32 pt)
        extendBy(self, SbBox3i32 bb)
        extendBy(self, SbVec3f pt)
        """
        return _coin.SbBox3i32_extendBy(self, *args)

    def transform(self, *args):
        """transform(self, SbMatrix m)"""
        return _coin.SbBox3i32_transform(self, *args)

    def makeEmpty(self):
        """makeEmpty(self)"""
        return _coin.SbBox3i32_makeEmpty(self)

    def isEmpty(self):
        """isEmpty(self) -> SbBool"""
        return _coin.SbBox3i32_isEmpty(self)

    def hasVolume(self):
        """hasVolume(self) -> SbBool"""
        return _coin.SbBox3i32_hasVolume(self)

    def getVolume(self):
        """getVolume(self) -> float"""
        return _coin.SbBox3i32_getVolume(self)

    def intersect(self, *args):
        """
        intersect(self, SbVec3i32 pt) -> SbBool
        intersect(self, SbBox3i32 bb) -> SbBool
        intersect(self, SbVec3f pt) -> SbBool
        """
        return _coin.SbBox3i32_intersect(self, *args)

    def outside(self, *args):
        """outside(self, SbMatrix MVP, int cullBits) -> SbBool"""
        return _coin.SbBox3i32_outside(self, *args)

    def getClosestPoint(self, *args):
        """getClosestPoint(self, SbVec3f pt) -> SbVec3f"""
        return _coin.SbBox3i32_getClosestPoint(self, *args)

    def getCenter(self):
        """getCenter(self) -> SbVec3f"""
        return _coin.SbBox3i32_getCenter(self)

    def getOrigin(self, *args):
        """getOrigin(self, int32_t originX, int32_t originY, int32_t originZ)"""
        return _coin.SbBox3i32_getOrigin(self, *args)

    def getSize(self, *args):
        """getSize(self, int32_t sizeX, int32_t sizeY, int32_t sizeZ)"""
        return _coin.SbBox3i32_getSize(self, *args)

    def getSpan(self, *args):
        """getSpan(self, SbVec3f direction, float dmin, float dmax)"""
        return _coin.SbBox3i32_getSpan(self, *args)

    __swig_destroy__ = _coin.delete_SbBox3i32
    __del__ = lambda self : None;
SbBox3i32_swigregister = _coin.SbBox3i32_swigregister
SbBox3i32_swigregister(SbBox3i32)

class SoSFBox3i32(SoSField):
    """Proxy of C++ SoSFBox3i32 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFBox3i32"""
        this = _coin.new_SoSFBox3i32()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFBox3i32
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFBox3i32_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFBox3i32_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFBox3i32_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFBox3i32_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFBox3i32_isSame(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoSFBox3i32 field) -> int"""
        return _coin.SoSFBox3i32___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFBox3i32 field) -> int"""
        return _coin.SoSFBox3i32___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFBox3i32_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbBox3i32 newvalue)
        setValue(self, int32_t xmin, int32_t ymin, int32_t zmin, int32_t xmax, 
            int32_t ymax, int32_t zmax)
        setValue(self, SbVec3i32 minvec, SbVec3i32 maxvec)
        """
        return _coin.SoSFBox3i32_setValue(self, *args)

    def getValue(self, *args):
        """
        getValue(self) -> SbBox3i32
        getValue(self, SbBox3i32 box)
        """
        return _coin.SoSFBox3i32_getValue(self, *args)

SoSFBox3i32_swigregister = _coin.SoSFBox3i32_swigregister
SoSFBox3i32_swigregister(SoSFBox3i32)

def SoSFBox3i32_createInstance():
  """SoSFBox3i32_createInstance() -> void"""
  return _coin.SoSFBox3i32_createInstance()

def SoSFBox3i32_getClassTypeId():
  """SoSFBox3i32_getClassTypeId() -> SoType"""
  return _coin.SoSFBox3i32_getClassTypeId()

def SoSFBox3i32_initClass():
  """SoSFBox3i32_initClass()"""
  return _coin.SoSFBox3i32_initClass()

class SoSFBox3f(SoSField):
    """Proxy of C++ SoSFBox3f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFBox3f"""
        this = _coin.new_SoSFBox3f()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFBox3f
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFBox3f_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFBox3f_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFBox3f_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFBox3f_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFBox3f_isSame(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoSFBox3f field) -> int"""
        return _coin.SoSFBox3f___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFBox3f field) -> int"""
        return _coin.SoSFBox3f___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFBox3f_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbBox3f newvalue)
        setValue(self, float xmin, float ymin, float zmin, float xmax, float ymax, 
            float zmax)
        setValue(self, SbVec3f minvec, SbVec3f maxvec)
        """
        return _coin.SoSFBox3f_setValue(self, *args)

    def getValue(self, *args):
        """
        getValue(self) -> SbBox3f
        getValue(self, SbBox3f box)
        """
        return _coin.SoSFBox3f_getValue(self, *args)

SoSFBox3f_swigregister = _coin.SoSFBox3f_swigregister
SoSFBox3f_swigregister(SoSFBox3f)

def SoSFBox3f_createInstance():
  """SoSFBox3f_createInstance() -> void"""
  return _coin.SoSFBox3f_createInstance()

def SoSFBox3f_getClassTypeId():
  """SoSFBox3f_getClassTypeId() -> SoType"""
  return _coin.SoSFBox3f_getClassTypeId()

def SoSFBox3f_initClass():
  """SoSFBox3f_initClass()"""
  return _coin.SoSFBox3f_initClass()

class SbBox3d(object):
    """Proxy of C++ SbBox3d class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbBox3d
        __init__(self, double xmin, double ymin, double zmin, double xmax, 
            double ymax, double zmax) -> SbBox3d
        __init__(self, SbVec3d minpoint, SbVec3d maxpoint) -> SbBox3d
        __init__(self, SbBox3f box) -> SbBox3d
        __init__(self, SbBox3s box) -> SbBox3d
        __init__(self, SbBox3i32 box) -> SbBox3d
        """
        this = _coin.new_SbBox3d(*args)
        try: self.this.append(this)
        except: self.this = this
    def setBounds(self, *args):
        """
        setBounds(self, double xmin, double ymin, double zmin, double xmax, 
            double ymax, double zmax) -> SbBox3d
        setBounds(self, SbVec3d minpoint, SbVec3d maxpoint) -> SbBox3d
        setBounds(self, SbBox3f box) -> SbBox3d
        setBounds(self, SbBox3s box) -> SbBox3d
        setBounds(self, SbBox3i32 box) -> SbBox3d
        """
        return _coin.SbBox3d_setBounds(self, *args)

    def getBounds(self, *args):
        """
        getBounds(self, double xmin, double ymin, double zmin, double xmax, 
            double ymax, double zmax)
        getBounds(self, SbVec3d minpoint, SbVec3d maxpoint)
        """
        return _coin.SbBox3d_getBounds(self, *args)

    def getMin(self, *args):
        """
        getMin(self) -> SbVec3d
        getMin(self) -> SbVec3d
        """
        return _coin.SbBox3d_getMin(self, *args)

    def getMax(self, *args):
        """
        getMax(self) -> SbVec3d
        getMax(self) -> SbVec3d
        """
        return _coin.SbBox3d_getMax(self, *args)

    def extendBy(self, *args):
        """
        extendBy(self, SbVec3d pt)
        extendBy(self, SbBox3d box)
        """
        return _coin.SbBox3d_extendBy(self, *args)

    def transform(self, *args):
        """transform(self, SbDPMatrix matrix)"""
        return _coin.SbBox3d_transform(self, *args)

    def makeEmpty(self):
        """makeEmpty(self)"""
        return _coin.SbBox3d_makeEmpty(self)

    def isEmpty(self):
        """isEmpty(self) -> SbBool"""
        return _coin.SbBox3d_isEmpty(self)

    def hasVolume(self):
        """hasVolume(self) -> SbBool"""
        return _coin.SbBox3d_hasVolume(self)

    def getVolume(self):
        """getVolume(self) -> double"""
        return _coin.SbBox3d_getVolume(self)

    def intersect(self, *args):
        """
        intersect(self, SbVec3d point) -> SbBool
        intersect(self, SbBox3d box) -> SbBool
        """
        return _coin.SbBox3d_intersect(self, *args)

    def getClosestPoint(self, *args):
        """getClosestPoint(self, SbVec3d point) -> SbVec3d"""
        return _coin.SbBox3d_getClosestPoint(self, *args)

    def outside(self, *args):
        """outside(self, SbDPMatrix mvp, int cullbits) -> SbBool"""
        return _coin.SbBox3d_outside(self, *args)

    def getCenter(self):
        """getCenter(self) -> SbVec3d"""
        return _coin.SbBox3d_getCenter(self)

    def getOrigin(self, *args):
        """getOrigin(self, double origoX, double origoY, double origoZ)"""
        return _coin.SbBox3d_getOrigin(self, *args)

    def getSize(self, *args):
        """
        getSize(self, double sizeX, double sizeY, double sizeZ)
        getSize(self) -> SbVec3d
        """
        return _coin.SbBox3d_getSize(self, *args)

    def getSpan(self, *args):
        """getSpan(self, SbVec3d dir, double dmin, double dmax)"""
        return _coin.SbBox3d_getSpan(self, *args)

    def output(self, *args):
        """output(self, FILE file)"""
        return _coin.SbBox3d_output(self, *args)

    __swig_destroy__ = _coin.delete_SbBox3d
    __del__ = lambda self : None;
SbBox3d_swigregister = _coin.SbBox3d_swigregister
SbBox3d_swigregister(SbBox3d)

class SoSFBox3d(SoSField):
    """Proxy of C++ SoSFBox3d class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFBox3d"""
        this = _coin.new_SoSFBox3d()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFBox3d
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFBox3d_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFBox3d_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFBox3d_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFBox3d_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFBox3d_isSame(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoSFBox3d field) -> int"""
        return _coin.SoSFBox3d___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFBox3d field) -> int"""
        return _coin.SoSFBox3d___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFBox3d_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbBox3d newvalue)
        setValue(self, double xmin, double ymin, double zmin, double xmax, 
            double ymax, double zmax)
        setValue(self, SbVec3d minvec, SbVec3d maxvec)
        """
        return _coin.SoSFBox3d_setValue(self, *args)

    def getValue(self, *args):
        """
        getValue(self) -> SbBox3d
        getValue(self, SbBox3d box)
        """
        return _coin.SoSFBox3d_getValue(self, *args)

SoSFBox3d_swigregister = _coin.SoSFBox3d_swigregister
SoSFBox3d_swigregister(SoSFBox3d)

def SoSFBox3d_createInstance():
  """SoSFBox3d_createInstance() -> void"""
  return _coin.SoSFBox3d_createInstance()

def SoSFBox3d_getClassTypeId():
  """SoSFBox3d_getClassTypeId() -> SoType"""
  return _coin.SoSFBox3d_getClassTypeId()

def SoSFBox3d_initClass():
  """SoSFBox3d_initClass()"""
  return _coin.SoSFBox3d_initClass()

class SoSFColorRGBA(SoSField):
    """Proxy of C++ SoSFColorRGBA class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFColorRGBA"""
        this = _coin.new_SoSFColorRGBA()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFColorRGBA
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFColorRGBA_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFColorRGBA_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFColorRGBA_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFColorRGBA_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFColorRGBA_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SbColor4f"""
        return _coin.SoSFColorRGBA_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFColorRGBA field) -> int"""
        return _coin.SoSFColorRGBA___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFColorRGBA field) -> int"""
        return _coin.SoSFColorRGBA___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFColorRGBA_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbColor4f newvalue)
        setValue(self, SbVec4f vec)
        setValue(self, float red, float green, float blue, float alpha)
        setValue(self, float rgba)
        """
        return _coin.SoSFColorRGBA_setValue(self, *args)

    def setHSVValue(self, *args):
        """
        setHSVValue(self, float h, float s, float v, float a)
        setHSVValue(self, float hsva)
        """
        return _coin.SoSFColorRGBA_setHSVValue(self, *args)

SoSFColorRGBA_swigregister = _coin.SoSFColorRGBA_swigregister
SoSFColorRGBA_swigregister(SoSFColorRGBA)

def SoSFColorRGBA_createInstance():
  """SoSFColorRGBA_createInstance() -> void"""
  return _coin.SoSFColorRGBA_createInstance()

def SoSFColorRGBA_getClassTypeId():
  """SoSFColorRGBA_getClassTypeId() -> SoType"""
  return _coin.SoSFColorRGBA_getClassTypeId()

def SoSFColorRGBA_initClass():
  """SoSFColorRGBA_initClass()"""
  return _coin.SoSFColorRGBA_initClass()

class SoSFDouble(SoSField):
    """Proxy of C++ SoSFDouble class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFDouble"""
        this = _coin.new_SoSFDouble()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFDouble
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFDouble_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFDouble_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFDouble_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFDouble_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFDouble_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> double"""
        return _coin.SoSFDouble_getValue(self)

    def setValue(self, *args):
        """setValue(self, double newvalue)"""
        return _coin.SoSFDouble_setValue(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoSFDouble field) -> int"""
        return _coin.SoSFDouble___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFDouble field) -> int"""
        return _coin.SoSFDouble___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFDouble_initClass()

    initClass = staticmethod(initClass)
SoSFDouble_swigregister = _coin.SoSFDouble_swigregister
SoSFDouble_swigregister(SoSFDouble)

def SoSFDouble_createInstance():
  """SoSFDouble_createInstance() -> void"""
  return _coin.SoSFDouble_createInstance()

def SoSFDouble_getClassTypeId():
  """SoSFDouble_getClassTypeId() -> SoType"""
  return _coin.SoSFDouble_getClassTypeId()

def SoSFDouble_initClass():
  """SoSFDouble_initClass()"""
  return _coin.SoSFDouble_initClass()

class SoSFEngine(SoSField):
    """Proxy of C++ SoSFEngine class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFEngine"""
        this = _coin.new_SoSFEngine()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFEngine
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFEngine_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFEngine_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFEngine_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFEngine_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFEngine_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SoEngine"""
        return _coin.SoSFEngine_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFEngine field) -> int"""
        return _coin.SoSFEngine___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFEngine field) -> int"""
        return _coin.SoSFEngine___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFEngine_initClass()

    initClass = staticmethod(initClass)
    def fixCopy(self, *args):
        """fixCopy(self, SbBool copyconnections)"""
        return _coin.SoSFEngine_fixCopy(self, *args)

    def referencesCopy(self):
        """referencesCopy(self) -> SbBool"""
        return _coin.SoSFEngine_referencesCopy(self)

    def setValue(self, *args):
        """
        setValue(self, SoEngine newvalue)
        setValue(self, SoSFEngine other)
        """
        return _coin.SoSFEngine_setValue(self, *args)

SoSFEngine_swigregister = _coin.SoSFEngine_swigregister
SoSFEngine_swigregister(SoSFEngine)

def SoSFEngine_createInstance():
  """SoSFEngine_createInstance() -> void"""
  return _coin.SoSFEngine_createInstance()

def SoSFEngine_getClassTypeId():
  """SoSFEngine_getClassTypeId() -> SoType"""
  return _coin.SoSFEngine_getClassTypeId()

def SoSFEngine_initClass():
  """SoSFEngine_initClass()"""
  return _coin.SoSFEngine_initClass()

class SoSFImage3(SoSField):
    """Proxy of C++ SoSFImage3 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFImage3"""
        this = _coin.new_SoSFImage3()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFImage3
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFImage3_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFImage3_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFImage3_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFImage3_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFImage3_isSame(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFImage3_initClass()

    initClass = staticmethod(initClass)
    def getValue(self):
        """getValue(self) -> unsigned char"""
        return _coin.SoSFImage3_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFImage3 field) -> int"""
        return _coin.SoSFImage3___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFImage3 field) -> int"""
        return _coin.SoSFImage3___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> unsigned char"""
        return _coin.SoSFImage3_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoSFImage3_finishEditing(self)

    def setValue(self, *args):
        """
        setValue(self, SbVec3s size, int nc, unsigned char bytes)
        setValue(self, SbVec3s size, int nc, PyObject pixels)
        setValue(self, SoSFImage3 other)
        """
        return _coin.SoSFImage3_setValue(self, *args)

SoSFImage3_swigregister = _coin.SoSFImage3_swigregister
SoSFImage3_swigregister(SoSFImage3)

def SoSFImage3_createInstance():
  """SoSFImage3_createInstance() -> void"""
  return _coin.SoSFImage3_createInstance()

def SoSFImage3_getClassTypeId():
  """SoSFImage3_getClassTypeId() -> SoType"""
  return _coin.SoSFImage3_getClassTypeId()

def SoSFImage3_initClass():
  """SoSFImage3_initClass()"""
  return _coin.SoSFImage3_initClass()

class SoSFMatrix(SoSField):
    """Proxy of C++ SoSFMatrix class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFMatrix"""
        this = _coin.new_SoSFMatrix()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFMatrix
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFMatrix_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFMatrix_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFMatrix_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFMatrix_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFMatrix_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SbMatrix"""
        return _coin.SoSFMatrix_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFMatrix field) -> int"""
        return _coin.SoSFMatrix___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFMatrix field) -> int"""
        return _coin.SoSFMatrix___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFMatrix_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbMatrix newvalue)
        setValue(self, float a11, float a12, float a13, float a14, float a21, 
            float a22, float a23, float a24, float a31, 
            float a32, float a33, float a34, float a41, 
            float a42, float a43, float a44)
        setValue(self, SoSFMatrix other)
        """
        return _coin.SoSFMatrix_setValue(self, *args)

SoSFMatrix_swigregister = _coin.SoSFMatrix_swigregister
SoSFMatrix_swigregister(SoSFMatrix)

def SoSFMatrix_createInstance():
  """SoSFMatrix_createInstance() -> void"""
  return _coin.SoSFMatrix_createInstance()

def SoSFMatrix_getClassTypeId():
  """SoSFMatrix_getClassTypeId() -> SoType"""
  return _coin.SoSFMatrix_getClassTypeId()

def SoSFMatrix_initClass():
  """SoSFMatrix_initClass()"""
  return _coin.SoSFMatrix_initClass()

class SoSFPlane(SoSField):
    """Proxy of C++ SoSFPlane class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFPlane"""
        this = _coin.new_SoSFPlane()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFPlane
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFPlane_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFPlane_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFPlane_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFPlane_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFPlane_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SbPlane"""
        return _coin.SoSFPlane_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFPlane field) -> int"""
        return _coin.SoSFPlane___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFPlane field) -> int"""
        return _coin.SoSFPlane___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFPlane_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbPlane newvalue)
        setValue(self, SoSFPlane other)
        """
        return _coin.SoSFPlane_setValue(self, *args)

SoSFPlane_swigregister = _coin.SoSFPlane_swigregister
SoSFPlane_swigregister(SoSFPlane)

def SoSFPlane_createInstance():
  """SoSFPlane_createInstance() -> void"""
  return _coin.SoSFPlane_createInstance()

def SoSFPlane_getClassTypeId():
  """SoSFPlane_getClassTypeId() -> SoType"""
  return _coin.SoSFPlane_getClassTypeId()

def SoSFPlane_initClass():
  """SoSFPlane_initClass()"""
  return _coin.SoSFPlane_initClass()

class SoSFUInt32(SoSField):
    """Proxy of C++ SoSFUInt32 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFUInt32"""
        this = _coin.new_SoSFUInt32()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFUInt32
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFUInt32_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFUInt32_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFUInt32_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFUInt32_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFUInt32_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> uint32_t"""
        return _coin.SoSFUInt32_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFUInt32 field) -> int"""
        return _coin.SoSFUInt32___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFUInt32 field) -> int"""
        return _coin.SoSFUInt32___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFUInt32_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, uint32_t newvalue)
        setValue(self, SoSFUInt32 other)
        """
        return _coin.SoSFUInt32_setValue(self, *args)

SoSFUInt32_swigregister = _coin.SoSFUInt32_swigregister
SoSFUInt32_swigregister(SoSFUInt32)

def SoSFUInt32_createInstance():
  """SoSFUInt32_createInstance() -> void"""
  return _coin.SoSFUInt32_createInstance()

def SoSFUInt32_getClassTypeId():
  """SoSFUInt32_getClassTypeId() -> SoType"""
  return _coin.SoSFUInt32_getClassTypeId()

def SoSFUInt32_initClass():
  """SoSFUInt32_initClass()"""
  return _coin.SoSFUInt32_initClass()

class SbVec2b(object):
    """Proxy of C++ SbVec2b class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbVec2b
        __init__(self, int8_t v) -> SbVec2b
        __init__(self, int8_t x, int8_t y) -> SbVec2b
        __init__(self, SbVec2ub v) -> SbVec2b
        __init__(self, SbVec2s v) -> SbVec2b
        __init__(self, SbVec2i32 v) -> SbVec2b
        __init__(self, SbVec2f v) -> SbVec2b
        __init__(self, SbVec2d v) -> SbVec2b
        """
        this = _coin.new_SbVec2b(*args)
        try: self.this.append(this)
        except: self.this = this
    def setValue(self, *args):
        """
        setValue(self, int8_t v) -> SbVec2b
        setValue(self, int8_t x, int8_t y) -> SbVec2b
        setValue(self, SbVec2ub v) -> SbVec2b
        setValue(self, SbVec2s v) -> SbVec2b
        setValue(self, SbVec2i32 v) -> SbVec2b
        setValue(self, SbVec2f v) -> SbVec2b
        setValue(self, SbVec2d v) -> SbVec2b
        """
        return _coin.SbVec2b_setValue(self, *args)

    def getValue(self, *args):
        """
        getValue(self) -> int8_t
        getValue(self, int8_t x, int8_t y)
        """
        return _coin.SbVec2b_getValue(self, *args)

    def dot(self, *args):
        """dot(self, SbVec2b v) -> int32_t"""
        return _coin.SbVec2b_dot(self, *args)

    def negate(self):
        """negate(self)"""
        return _coin.SbVec2b_negate(self)

    def __imul__(self, *args):
        """
        __imul__(self, int d) -> SbVec2b
        __imul__(self, double d) -> SbVec2b
        """
        return _coin.SbVec2b___imul__(self, *args)

    def __idiv__(self, *args):
        """
        __idiv__(self, int d) -> SbVec2b
        __idiv__(self, double d) -> SbVec2b
        """
        return _coin.SbVec2b___idiv__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, SbVec2b v) -> SbVec2b"""
        return _coin.SbVec2b___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, SbVec2b v) -> SbVec2b"""
        return _coin.SbVec2b___isub__(self, *args)

    def __neg__(self):
        """__neg__(self) -> SbVec2b"""
        return _coin.SbVec2b___neg__(self)

    __swig_destroy__ = _coin.delete_SbVec2b
    __del__ = lambda self : None;
SbVec2b_swigregister = _coin.SbVec2b_swigregister
SbVec2b_swigregister(SbVec2b)

class SoSFVec2b(SoSField):
    """Proxy of C++ SoSFVec2b class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFVec2b"""
        this = _coin.new_SoSFVec2b()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFVec2b
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFVec2b_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFVec2b_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFVec2b_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFVec2b_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFVec2b_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SbVec2b"""
        return _coin.SoSFVec2b_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFVec2b field) -> int"""
        return _coin.SoSFVec2b___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFVec2b field) -> int"""
        return _coin.SoSFVec2b___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFVec2b_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbVec2b newvalue)
        setValue(self, int8_t x, int8_t y)
        setValue(self, int8_t xy)
        """
        return _coin.SoSFVec2b_setValue(self, *args)

SoSFVec2b_swigregister = _coin.SoSFVec2b_swigregister
SoSFVec2b_swigregister(SoSFVec2b)

def SoSFVec2b_createInstance():
  """SoSFVec2b_createInstance() -> void"""
  return _coin.SoSFVec2b_createInstance()

def SoSFVec2b_getClassTypeId():
  """SoSFVec2b_getClassTypeId() -> SoType"""
  return _coin.SoSFVec2b_getClassTypeId()

def SoSFVec2b_initClass():
  """SoSFVec2b_initClass()"""
  return _coin.SoSFVec2b_initClass()

class SoSFVec2s(SoSField):
    """Proxy of C++ SoSFVec2s class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFVec2s"""
        this = _coin.new_SoSFVec2s()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFVec2s
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFVec2s_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFVec2s_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFVec2s_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFVec2s_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFVec2s_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SbVec2s"""
        return _coin.SoSFVec2s_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFVec2s field) -> int"""
        return _coin.SoSFVec2s___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFVec2s field) -> int"""
        return _coin.SoSFVec2s___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFVec2s_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbVec2s newvalue)
        setValue(self, short x, short y)
        setValue(self, short xy)
        """
        return _coin.SoSFVec2s_setValue(self, *args)

SoSFVec2s_swigregister = _coin.SoSFVec2s_swigregister
SoSFVec2s_swigregister(SoSFVec2s)

def SoSFVec2s_createInstance():
  """SoSFVec2s_createInstance() -> void"""
  return _coin.SoSFVec2s_createInstance()

def SoSFVec2s_getClassTypeId():
  """SoSFVec2s_getClassTypeId() -> SoType"""
  return _coin.SoSFVec2s_getClassTypeId()

def SoSFVec2s_initClass():
  """SoSFVec2s_initClass()"""
  return _coin.SoSFVec2s_initClass()

class SoSFVec2i32(SoSField):
    """Proxy of C++ SoSFVec2i32 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFVec2i32"""
        this = _coin.new_SoSFVec2i32()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFVec2i32
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFVec2i32_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFVec2i32_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFVec2i32_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFVec2i32_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFVec2i32_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SbVec2i32"""
        return _coin.SoSFVec2i32_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFVec2i32 field) -> int"""
        return _coin.SoSFVec2i32___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFVec2i32 field) -> int"""
        return _coin.SoSFVec2i32___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFVec2i32_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbVec2i32 newvalue)
        setValue(self, int32_t x, int32_t y)
        setValue(self, int32_t xy)
        """
        return _coin.SoSFVec2i32_setValue(self, *args)

SoSFVec2i32_swigregister = _coin.SoSFVec2i32_swigregister
SoSFVec2i32_swigregister(SoSFVec2i32)

def SoSFVec2i32_createInstance():
  """SoSFVec2i32_createInstance() -> void"""
  return _coin.SoSFVec2i32_createInstance()

def SoSFVec2i32_getClassTypeId():
  """SoSFVec2i32_getClassTypeId() -> SoType"""
  return _coin.SoSFVec2i32_getClassTypeId()

def SoSFVec2i32_initClass():
  """SoSFVec2i32_initClass()"""
  return _coin.SoSFVec2i32_initClass()

class SoSFVec2d(SoSField):
    """Proxy of C++ SoSFVec2d class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFVec2d"""
        this = _coin.new_SoSFVec2d()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFVec2d
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFVec2d_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFVec2d_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFVec2d_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFVec2d_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFVec2d_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SbVec2d"""
        return _coin.SoSFVec2d_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFVec2d field) -> int"""
        return _coin.SoSFVec2d___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFVec2d field) -> int"""
        return _coin.SoSFVec2d___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFVec2d_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbVec2d newvalue)
        setValue(self, double x, double y)
        setValue(self, double xy)
        """
        return _coin.SoSFVec2d_setValue(self, *args)

SoSFVec2d_swigregister = _coin.SoSFVec2d_swigregister
SoSFVec2d_swigregister(SoSFVec2d)

def SoSFVec2d_createInstance():
  """SoSFVec2d_createInstance() -> void"""
  return _coin.SoSFVec2d_createInstance()

def SoSFVec2d_getClassTypeId():
  """SoSFVec2d_getClassTypeId() -> SoType"""
  return _coin.SoSFVec2d_getClassTypeId()

def SoSFVec2d_initClass():
  """SoSFVec2d_initClass()"""
  return _coin.SoSFVec2d_initClass()

class SbVec3b(object):
    """Proxy of C++ SbVec3b class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbVec3b
        __init__(self, int8_t v) -> SbVec3b
        __init__(self, int8_t x, int8_t y, int8_t z) -> SbVec3b
        __init__(self, SbVec3ub v) -> SbVec3b
        __init__(self, SbVec3s v) -> SbVec3b
        __init__(self, SbVec3i32 v) -> SbVec3b
        __init__(self, SbVec3f v) -> SbVec3b
        __init__(self, SbVec3d v) -> SbVec3b
        """
        this = _coin.new_SbVec3b(*args)
        try: self.this.append(this)
        except: self.this = this
    def setValue(self, *args):
        """
        setValue(self, int8_t v) -> SbVec3b
        setValue(self, int8_t x, int8_t y, int8_t z) -> SbVec3b
        setValue(self, SbVec3ub v) -> SbVec3b
        setValue(self, SbVec3s v) -> SbVec3b
        setValue(self, SbVec3i32 v) -> SbVec3b
        setValue(self, SbVec3f v) -> SbVec3b
        setValue(self, SbVec3d v) -> SbVec3b
        """
        return _coin.SbVec3b_setValue(self, *args)

    def getValue(self, *args):
        """
        getValue(self) -> int8_t
        getValue(self, int8_t x, int8_t y, int8_t z)
        """
        return _coin.SbVec3b_getValue(self, *args)

    def dot(self, *args):
        """dot(self, SbVec3b v) -> int32_t"""
        return _coin.SbVec3b_dot(self, *args)

    def negate(self):
        """negate(self)"""
        return _coin.SbVec3b_negate(self)

    def __imul__(self, *args):
        """
        __imul__(self, int d) -> SbVec3b
        __imul__(self, double d) -> SbVec3b
        """
        return _coin.SbVec3b___imul__(self, *args)

    def __idiv__(self, *args):
        """
        __idiv__(self, int d) -> SbVec3b
        __idiv__(self, double d) -> SbVec3b
        """
        return _coin.SbVec3b___idiv__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, SbVec3b v) -> SbVec3b"""
        return _coin.SbVec3b___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, SbVec3b v) -> SbVec3b"""
        return _coin.SbVec3b___isub__(self, *args)

    def __neg__(self):
        """__neg__(self) -> SbVec3b"""
        return _coin.SbVec3b___neg__(self)

    __swig_destroy__ = _coin.delete_SbVec3b
    __del__ = lambda self : None;
SbVec3b_swigregister = _coin.SbVec3b_swigregister
SbVec3b_swigregister(SbVec3b)

class SoSFVec3b(SoSField):
    """Proxy of C++ SoSFVec3b class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFVec3b"""
        this = _coin.new_SoSFVec3b()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFVec3b
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFVec3b_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFVec3b_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFVec3b_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFVec3b_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFVec3b_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SbVec3b"""
        return _coin.SoSFVec3b_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFVec3b field) -> int"""
        return _coin.SoSFVec3b___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFVec3b field) -> int"""
        return _coin.SoSFVec3b___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFVec3b_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbVec3b newvalue)
        setValue(self, int8_t x, int8_t y, int8_t z)
        setValue(self, int8_t xyz)
        """
        return _coin.SoSFVec3b_setValue(self, *args)

SoSFVec3b_swigregister = _coin.SoSFVec3b_swigregister
SoSFVec3b_swigregister(SoSFVec3b)

def SoSFVec3b_createInstance():
  """SoSFVec3b_createInstance() -> void"""
  return _coin.SoSFVec3b_createInstance()

def SoSFVec3b_getClassTypeId():
  """SoSFVec3b_getClassTypeId() -> SoType"""
  return _coin.SoSFVec3b_getClassTypeId()

def SoSFVec3b_initClass():
  """SoSFVec3b_initClass()"""
  return _coin.SoSFVec3b_initClass()

class SoSFVec3s(SoSField):
    """Proxy of C++ SoSFVec3s class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFVec3s"""
        this = _coin.new_SoSFVec3s()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFVec3s
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFVec3s_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFVec3s_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFVec3s_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFVec3s_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFVec3s_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SbVec3s"""
        return _coin.SoSFVec3s_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFVec3s field) -> int"""
        return _coin.SoSFVec3s___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFVec3s field) -> int"""
        return _coin.SoSFVec3s___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFVec3s_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbVec3s newvalue)
        setValue(self, short x, short y, short z)
        setValue(self, short xyz)
        """
        return _coin.SoSFVec3s_setValue(self, *args)

SoSFVec3s_swigregister = _coin.SoSFVec3s_swigregister
SoSFVec3s_swigregister(SoSFVec3s)

def SoSFVec3s_createInstance():
  """SoSFVec3s_createInstance() -> void"""
  return _coin.SoSFVec3s_createInstance()

def SoSFVec3s_getClassTypeId():
  """SoSFVec3s_getClassTypeId() -> SoType"""
  return _coin.SoSFVec3s_getClassTypeId()

def SoSFVec3s_initClass():
  """SoSFVec3s_initClass()"""
  return _coin.SoSFVec3s_initClass()

class SoSFVec3i32(SoSField):
    """Proxy of C++ SoSFVec3i32 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFVec3i32"""
        this = _coin.new_SoSFVec3i32()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFVec3i32
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFVec3i32_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFVec3i32_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFVec3i32_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFVec3i32_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFVec3i32_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SbVec3i32"""
        return _coin.SoSFVec3i32_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFVec3i32 field) -> int"""
        return _coin.SoSFVec3i32___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFVec3i32 field) -> int"""
        return _coin.SoSFVec3i32___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFVec3i32_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbVec3i32 newvalue)
        setValue(self, int32_t x, int32_t y, int32_t z)
        setValue(self, int32_t xyz)
        """
        return _coin.SoSFVec3i32_setValue(self, *args)

SoSFVec3i32_swigregister = _coin.SoSFVec3i32_swigregister
SoSFVec3i32_swigregister(SoSFVec3i32)

def SoSFVec3i32_createInstance():
  """SoSFVec3i32_createInstance() -> void"""
  return _coin.SoSFVec3i32_createInstance()

def SoSFVec3i32_getClassTypeId():
  """SoSFVec3i32_getClassTypeId() -> SoType"""
  return _coin.SoSFVec3i32_getClassTypeId()

def SoSFVec3i32_initClass():
  """SoSFVec3i32_initClass()"""
  return _coin.SoSFVec3i32_initClass()

class SoSFVec3d(SoSField):
    """Proxy of C++ SoSFVec3d class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFVec3d"""
        this = _coin.new_SoSFVec3d()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFVec3d
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFVec3d_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFVec3d_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFVec3d_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFVec3d_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFVec3d_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SbVec3d"""
        return _coin.SoSFVec3d_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFVec3d field) -> int"""
        return _coin.SoSFVec3d___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFVec3d field) -> int"""
        return _coin.SoSFVec3d___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFVec3d_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbVec3d newvalue)
        setValue(self, double x, double y, double z)
        setValue(self, double xyz)
        """
        return _coin.SoSFVec3d_setValue(self, *args)

SoSFVec3d_swigregister = _coin.SoSFVec3d_swigregister
SoSFVec3d_swigregister(SoSFVec3d)

def SoSFVec3d_createInstance():
  """SoSFVec3d_createInstance() -> void"""
  return _coin.SoSFVec3d_createInstance()

def SoSFVec3d_getClassTypeId():
  """SoSFVec3d_getClassTypeId() -> SoType"""
  return _coin.SoSFVec3d_getClassTypeId()

def SoSFVec3d_initClass():
  """SoSFVec3d_initClass()"""
  return _coin.SoSFVec3d_initClass()

class SbVec4b(object):
    """Proxy of C++ SbVec4b class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbVec4b
        __init__(self, int8_t v) -> SbVec4b
        __init__(self, int8_t x, int8_t y, int8_t z, int8_t w) -> SbVec4b
        __init__(self, SbVec4ub v) -> SbVec4b
        __init__(self, SbVec4s v) -> SbVec4b
        __init__(self, SbVec4i32 v) -> SbVec4b
        __init__(self, SbVec4f v) -> SbVec4b
        __init__(self, SbVec4d v) -> SbVec4b
        """
        this = _coin.new_SbVec4b(*args)
        try: self.this.append(this)
        except: self.this = this
    def setValue(self, *args):
        """
        setValue(self, int8_t v) -> SbVec4b
        setValue(self, int8_t x, int8_t y, int8_t z, int8_t w) -> SbVec4b
        setValue(self, SbVec4ub v) -> SbVec4b
        setValue(self, SbVec4s v) -> SbVec4b
        setValue(self, SbVec4i32 v) -> SbVec4b
        setValue(self, SbVec4f v) -> SbVec4b
        setValue(self, SbVec4d v) -> SbVec4b
        """
        return _coin.SbVec4b_setValue(self, *args)

    def getValue(self, *args):
        """
        getValue(self) -> int8_t
        getValue(self, int8_t x, int8_t y, int8_t z, int8_t w)
        """
        return _coin.SbVec4b_getValue(self, *args)

    def dot(self, *args):
        """dot(self, SbVec4b v) -> int32_t"""
        return _coin.SbVec4b_dot(self, *args)

    def negate(self):
        """negate(self)"""
        return _coin.SbVec4b_negate(self)

    def __imul__(self, *args):
        """
        __imul__(self, int d) -> SbVec4b
        __imul__(self, double d) -> SbVec4b
        """
        return _coin.SbVec4b___imul__(self, *args)

    def __idiv__(self, *args):
        """
        __idiv__(self, int d) -> SbVec4b
        __idiv__(self, double d) -> SbVec4b
        """
        return _coin.SbVec4b___idiv__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, SbVec4b v) -> SbVec4b"""
        return _coin.SbVec4b___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, SbVec4b v) -> SbVec4b"""
        return _coin.SbVec4b___isub__(self, *args)

    def __neg__(self):
        """__neg__(self) -> SbVec4b"""
        return _coin.SbVec4b___neg__(self)

    __swig_destroy__ = _coin.delete_SbVec4b
    __del__ = lambda self : None;
SbVec4b_swigregister = _coin.SbVec4b_swigregister
SbVec4b_swigregister(SbVec4b)

class SoSFVec4b(SoSField):
    """Proxy of C++ SoSFVec4b class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFVec4b"""
        this = _coin.new_SoSFVec4b()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFVec4b
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFVec4b_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFVec4b_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFVec4b_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFVec4b_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFVec4b_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SbVec4b"""
        return _coin.SoSFVec4b_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFVec4b field) -> int"""
        return _coin.SoSFVec4b___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFVec4b field) -> int"""
        return _coin.SoSFVec4b___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFVec4b_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbVec4b newvalue)
        setValue(self, int8_t x, int8_t y, int8_t z, int8_t w)
        setValue(self, int8_t xyzw)
        """
        return _coin.SoSFVec4b_setValue(self, *args)

SoSFVec4b_swigregister = _coin.SoSFVec4b_swigregister
SoSFVec4b_swigregister(SoSFVec4b)

def SoSFVec4b_createInstance():
  """SoSFVec4b_createInstance() -> void"""
  return _coin.SoSFVec4b_createInstance()

def SoSFVec4b_getClassTypeId():
  """SoSFVec4b_getClassTypeId() -> SoType"""
  return _coin.SoSFVec4b_getClassTypeId()

def SoSFVec4b_initClass():
  """SoSFVec4b_initClass()"""
  return _coin.SoSFVec4b_initClass()

class SbVec4ub(object):
    """Proxy of C++ SbVec4ub class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbVec4ub
        __init__(self, uint8_t v) -> SbVec4ub
        __init__(self, uint8_t x, uint8_t y, uint8_t z, uint8_t w) -> SbVec4ub
        __init__(self, SbVec4b v) -> SbVec4ub
        __init__(self, SbVec4us v) -> SbVec4ub
        __init__(self, SbVec4ui32 v) -> SbVec4ub
        """
        this = _coin.new_SbVec4ub(*args)
        try: self.this.append(this)
        except: self.this = this
    def setValue(self, *args):
        """
        setValue(self, uint8_t v) -> SbVec4ub
        setValue(self, uint8_t x, uint8_t y, uint8_t z, uint8_t w) -> SbVec4ub
        setValue(self, SbVec4b v) -> SbVec4ub
        setValue(self, SbVec4us v) -> SbVec4ub
        setValue(self, SbVec4ui32 v) -> SbVec4ub
        """
        return _coin.SbVec4ub_setValue(self, *args)

    def getValue(self, *args):
        """
        getValue(self) -> uint8_t
        getValue(self, uint8_t x, uint8_t y, uint8_t z, uint8_t w)
        """
        return _coin.SbVec4ub_getValue(self, *args)

    def dot(self, *args):
        """dot(self, SbVec4ub v) -> int32_t"""
        return _coin.SbVec4ub_dot(self, *args)

    def negate(self):
        """negate(self)"""
        return _coin.SbVec4ub_negate(self)

    def __imul__(self, *args):
        """
        __imul__(self, int d) -> SbVec4ub
        __imul__(self, double d) -> SbVec4ub
        """
        return _coin.SbVec4ub___imul__(self, *args)

    def __idiv__(self, *args):
        """
        __idiv__(self, int d) -> SbVec4ub
        __idiv__(self, double d) -> SbVec4ub
        """
        return _coin.SbVec4ub___idiv__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, SbVec4ub v) -> SbVec4ub"""
        return _coin.SbVec4ub___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, SbVec4ub v) -> SbVec4ub"""
        return _coin.SbVec4ub___isub__(self, *args)

    def __neg__(self):
        """__neg__(self) -> SbVec4ub"""
        return _coin.SbVec4ub___neg__(self)

    __swig_destroy__ = _coin.delete_SbVec4ub
    __del__ = lambda self : None;
SbVec4ub_swigregister = _coin.SbVec4ub_swigregister
SbVec4ub_swigregister(SbVec4ub)

class SoSFVec4ub(SoSField):
    """Proxy of C++ SoSFVec4ub class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFVec4ub"""
        this = _coin.new_SoSFVec4ub()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFVec4ub
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFVec4ub_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFVec4ub_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFVec4ub_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFVec4ub_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFVec4ub_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SbVec4ub"""
        return _coin.SoSFVec4ub_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFVec4ub field) -> int"""
        return _coin.SoSFVec4ub___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFVec4ub field) -> int"""
        return _coin.SoSFVec4ub___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFVec4ub_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbVec4ub newvalue)
        setValue(self, uint8_t x, uint8_t y, uint8_t z, uint8_t w)
        setValue(self, uint8_t xyzw)
        """
        return _coin.SoSFVec4ub_setValue(self, *args)

SoSFVec4ub_swigregister = _coin.SoSFVec4ub_swigregister
SoSFVec4ub_swigregister(SoSFVec4ub)

def SoSFVec4ub_createInstance():
  """SoSFVec4ub_createInstance() -> void"""
  return _coin.SoSFVec4ub_createInstance()

def SoSFVec4ub_getClassTypeId():
  """SoSFVec4ub_getClassTypeId() -> SoType"""
  return _coin.SoSFVec4ub_getClassTypeId()

def SoSFVec4ub_initClass():
  """SoSFVec4ub_initClass()"""
  return _coin.SoSFVec4ub_initClass()

class SbVec4s(object):
    """Proxy of C++ SbVec4s class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbVec4s
        __init__(self, short v) -> SbVec4s
        __init__(self, short x, short y, short z, short w) -> SbVec4s
        __init__(self, SbVec4us v) -> SbVec4s
        __init__(self, SbVec4b v) -> SbVec4s
        __init__(self, SbVec4i32 v) -> SbVec4s
        __init__(self, SbVec4f v) -> SbVec4s
        __init__(self, SbVec4d v) -> SbVec4s
        """
        this = _coin.new_SbVec4s(*args)
        try: self.this.append(this)
        except: self.this = this
    def setValue(self, *args):
        """
        setValue(self, short v) -> SbVec4s
        setValue(self, short x, short y, short z, short w) -> SbVec4s
        setValue(self, SbVec4s v) -> SbVec4s
        setValue(self, SbVec4us v) -> SbVec4s
        setValue(self, SbVec4b v) -> SbVec4s
        setValue(self, SbVec4i32 v) -> SbVec4s
        setValue(self, SbVec4f v) -> SbVec4s
        setValue(self, SbVec4d v) -> SbVec4s
        """
        return _coin.SbVec4s_setValue(self, *args)

    def getValue(self, *args):
        """
        getValue(self) -> short
        getValue(self, short w)
        """
        return _coin.SbVec4s_getValue(self, *args)

    def dot(self, *args):
        """dot(self, SbVec4s v) -> int32_t"""
        return _coin.SbVec4s_dot(self, *args)

    def negate(self):
        """negate(self)"""
        return _coin.SbVec4s_negate(self)

    def __imul__(self, *args):
        """
        __imul__(self, int d) -> SbVec4s
        __imul__(self, double d) -> SbVec4s
        """
        return _coin.SbVec4s___imul__(self, *args)

    def __idiv__(self, *args):
        """
        __idiv__(self, int d) -> SbVec4s
        __idiv__(self, double d) -> SbVec4s
        """
        return _coin.SbVec4s___idiv__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, SbVec4s v) -> SbVec4s"""
        return _coin.SbVec4s___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, SbVec4s v) -> SbVec4s"""
        return _coin.SbVec4s___isub__(self, *args)

    def __neg__(self):
        """__neg__(self) -> SbVec4s"""
        return _coin.SbVec4s___neg__(self)

    __swig_destroy__ = _coin.delete_SbVec4s
    __del__ = lambda self : None;
SbVec4s_swigregister = _coin.SbVec4s_swigregister
SbVec4s_swigregister(SbVec4s)

class SoSFVec4s(SoSField):
    """Proxy of C++ SoSFVec4s class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFVec4s"""
        this = _coin.new_SoSFVec4s()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFVec4s
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFVec4s_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFVec4s_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFVec4s_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFVec4s_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFVec4s_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SbVec4s"""
        return _coin.SoSFVec4s_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFVec4s field) -> int"""
        return _coin.SoSFVec4s___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFVec4s field) -> int"""
        return _coin.SoSFVec4s___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFVec4s_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbVec4s newvalue)
        setValue(self, short x, short y, short z, short w)
        setValue(self, short xyzw)
        """
        return _coin.SoSFVec4s_setValue(self, *args)

SoSFVec4s_swigregister = _coin.SoSFVec4s_swigregister
SoSFVec4s_swigregister(SoSFVec4s)

def SoSFVec4s_createInstance():
  """SoSFVec4s_createInstance() -> void"""
  return _coin.SoSFVec4s_createInstance()

def SoSFVec4s_getClassTypeId():
  """SoSFVec4s_getClassTypeId() -> SoType"""
  return _coin.SoSFVec4s_getClassTypeId()

def SoSFVec4s_initClass():
  """SoSFVec4s_initClass()"""
  return _coin.SoSFVec4s_initClass()

class SbVec4us(object):
    """Proxy of C++ SbVec4us class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbVec4us
        __init__(self, unsigned short v) -> SbVec4us
        __init__(self, unsigned short x, unsigned short y, unsigned short z, 
            unsigned short w) -> SbVec4us
        __init__(self, SbVec4s v) -> SbVec4us
        __init__(self, SbVec4ub v) -> SbVec4us
        __init__(self, SbVec4ui32 v) -> SbVec4us
        """
        this = _coin.new_SbVec4us(*args)
        try: self.this.append(this)
        except: self.this = this
    def setValue(self, *args):
        """
        setValue(self, unsigned short v) -> SbVec4us
        setValue(self, unsigned short x, unsigned short y, unsigned short z, 
            unsigned short w) -> SbVec4us
        setValue(self, SbVec4s v) -> SbVec4us
        setValue(self, SbVec4ub v) -> SbVec4us
        setValue(self, SbVec4ui32 v) -> SbVec4us
        """
        return _coin.SbVec4us_setValue(self, *args)

    def getValue(self, *args):
        """
        getValue(self) -> unsigned short
        getValue(self, unsigned short x, unsigned short y, unsigned short z, 
            unsigned short w)
        """
        return _coin.SbVec4us_getValue(self, *args)

    def dot(self, *args):
        """dot(self, SbVec4us v) -> int32_t"""
        return _coin.SbVec4us_dot(self, *args)

    def negate(self):
        """negate(self)"""
        return _coin.SbVec4us_negate(self)

    def __imul__(self, *args):
        """
        __imul__(self, int d) -> SbVec4us
        __imul__(self, double d) -> SbVec4us
        """
        return _coin.SbVec4us___imul__(self, *args)

    def __idiv__(self, *args):
        """
        __idiv__(self, int d) -> SbVec4us
        __idiv__(self, double d) -> SbVec4us
        """
        return _coin.SbVec4us___idiv__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, SbVec4us v) -> SbVec4us"""
        return _coin.SbVec4us___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, SbVec4us v) -> SbVec4us"""
        return _coin.SbVec4us___isub__(self, *args)

    def __neg__(self):
        """__neg__(self) -> SbVec4us"""
        return _coin.SbVec4us___neg__(self)

    __swig_destroy__ = _coin.delete_SbVec4us
    __del__ = lambda self : None;
SbVec4us_swigregister = _coin.SbVec4us_swigregister
SbVec4us_swigregister(SbVec4us)

class SoSFVec4us(SoSField):
    """Proxy of C++ SoSFVec4us class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFVec4us"""
        this = _coin.new_SoSFVec4us()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFVec4us
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFVec4us_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFVec4us_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFVec4us_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFVec4us_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFVec4us_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SbVec4us"""
        return _coin.SoSFVec4us_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFVec4us field) -> int"""
        return _coin.SoSFVec4us___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFVec4us field) -> int"""
        return _coin.SoSFVec4us___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFVec4us_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbVec4us newvalue)
        setValue(self, unsigned short x, unsigned short y, unsigned short z, 
            unsigned short w)
        setValue(self, unsigned short xyzw)
        """
        return _coin.SoSFVec4us_setValue(self, *args)

SoSFVec4us_swigregister = _coin.SoSFVec4us_swigregister
SoSFVec4us_swigregister(SoSFVec4us)

def SoSFVec4us_createInstance():
  """SoSFVec4us_createInstance() -> void"""
  return _coin.SoSFVec4us_createInstance()

def SoSFVec4us_getClassTypeId():
  """SoSFVec4us_getClassTypeId() -> SoType"""
  return _coin.SoSFVec4us_getClassTypeId()

def SoSFVec4us_initClass():
  """SoSFVec4us_initClass()"""
  return _coin.SoSFVec4us_initClass()

class SbVec4i32(object):
    """Proxy of C++ SbVec4i32 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbVec4i32
        __init__(self, int32_t v) -> SbVec4i32
        __init__(self, int32_t x, int32_t y, int32_t z, int32_t w) -> SbVec4i32
        __init__(self, SbVec4ui32 v) -> SbVec4i32
        __init__(self, SbVec4b v) -> SbVec4i32
        __init__(self, SbVec4s v) -> SbVec4i32
        __init__(self, SbVec4f v) -> SbVec4i32
        __init__(self, SbVec4d v) -> SbVec4i32
        """
        this = _coin.new_SbVec4i32(*args)
        try: self.this.append(this)
        except: self.this = this
    def setValue(self, *args):
        """
        setValue(self, int32_t v) -> SbVec4i32
        setValue(self, int32_t x, int32_t y, int32_t z, int32_t w) -> SbVec4i32
        setValue(self, SbVec4ui32 v) -> SbVec4i32
        setValue(self, SbVec4b v) -> SbVec4i32
        setValue(self, SbVec4s v) -> SbVec4i32
        setValue(self, SbVec4f v) -> SbVec4i32
        setValue(self, SbVec4d v) -> SbVec4i32
        """
        return _coin.SbVec4i32_setValue(self, *args)

    def getValue(self, *args):
        """
        getValue(self) -> int32_t
        getValue(self, int32_t x, int32_t y, int32_t z, int32_t w)
        """
        return _coin.SbVec4i32_getValue(self, *args)

    def dot(self, *args):
        """dot(self, SbVec4i32 v) -> int32_t"""
        return _coin.SbVec4i32_dot(self, *args)

    def negate(self):
        """negate(self)"""
        return _coin.SbVec4i32_negate(self)

    def __imul__(self, *args):
        """
        __imul__(self, int d) -> SbVec4i32
        __imul__(self, double d) -> SbVec4i32
        """
        return _coin.SbVec4i32___imul__(self, *args)

    def __idiv__(self, *args):
        """
        __idiv__(self, int d) -> SbVec4i32
        __idiv__(self, double d) -> SbVec4i32
        """
        return _coin.SbVec4i32___idiv__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, SbVec4i32 v) -> SbVec4i32"""
        return _coin.SbVec4i32___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, SbVec4i32 v) -> SbVec4i32"""
        return _coin.SbVec4i32___isub__(self, *args)

    def __neg__(self):
        """__neg__(self) -> SbVec4i32"""
        return _coin.SbVec4i32___neg__(self)

    __swig_destroy__ = _coin.delete_SbVec4i32
    __del__ = lambda self : None;
SbVec4i32_swigregister = _coin.SbVec4i32_swigregister
SbVec4i32_swigregister(SbVec4i32)

class SoSFVec4i32(SoSField):
    """Proxy of C++ SoSFVec4i32 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFVec4i32"""
        this = _coin.new_SoSFVec4i32()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFVec4i32
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFVec4i32_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFVec4i32_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFVec4i32_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFVec4i32_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFVec4i32_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SbVec4i32"""
        return _coin.SoSFVec4i32_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFVec4i32 field) -> int"""
        return _coin.SoSFVec4i32___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFVec4i32 field) -> int"""
        return _coin.SoSFVec4i32___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFVec4i32_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbVec4i32 newvalue)
        setValue(self, int32_t x, int32_t y, int32_t z, int32_t w)
        setValue(self, int32_t xyzw)
        """
        return _coin.SoSFVec4i32_setValue(self, *args)

SoSFVec4i32_swigregister = _coin.SoSFVec4i32_swigregister
SoSFVec4i32_swigregister(SoSFVec4i32)

def SoSFVec4i32_createInstance():
  """SoSFVec4i32_createInstance() -> void"""
  return _coin.SoSFVec4i32_createInstance()

def SoSFVec4i32_getClassTypeId():
  """SoSFVec4i32_getClassTypeId() -> SoType"""
  return _coin.SoSFVec4i32_getClassTypeId()

def SoSFVec4i32_initClass():
  """SoSFVec4i32_initClass()"""
  return _coin.SoSFVec4i32_initClass()

class SbVec4ui32(object):
    """Proxy of C++ SbVec4ui32 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbVec4ui32
        __init__(self, uint32_t v) -> SbVec4ui32
        __init__(self, uint32_t x, uint32_t y, uint32_t z, uint32_t w) -> SbVec4ui32
        __init__(self, SbVec4i32 v) -> SbVec4ui32
        __init__(self, SbVec4ub v) -> SbVec4ui32
        __init__(self, SbVec4us v) -> SbVec4ui32
        """
        this = _coin.new_SbVec4ui32(*args)
        try: self.this.append(this)
        except: self.this = this
    def setValue(self, *args):
        """
        setValue(self, uint32_t v) -> SbVec4ui32
        setValue(self, uint32_t x, uint32_t y, uint32_t z, uint32_t w) -> SbVec4ui32
        setValue(self, SbVec4i32 v) -> SbVec4ui32
        setValue(self, SbVec4ub v) -> SbVec4ui32
        setValue(self, SbVec4us v) -> SbVec4ui32
        """
        return _coin.SbVec4ui32_setValue(self, *args)

    def getValue(self, *args):
        """
        getValue(self) -> uint32_t
        getValue(self, uint32_t x, uint32_t y, uint32_t z, uint32_t w)
        """
        return _coin.SbVec4ui32_getValue(self, *args)

    def dot(self, *args):
        """dot(self, SbVec4ui32 v) -> int32_t"""
        return _coin.SbVec4ui32_dot(self, *args)

    def negate(self):
        """negate(self)"""
        return _coin.SbVec4ui32_negate(self)

    def __imul__(self, *args):
        """
        __imul__(self, int d) -> SbVec4ui32
        __imul__(self, double d) -> SbVec4ui32
        """
        return _coin.SbVec4ui32___imul__(self, *args)

    def __idiv__(self, *args):
        """
        __idiv__(self, int d) -> SbVec4ui32
        __idiv__(self, double d) -> SbVec4ui32
        """
        return _coin.SbVec4ui32___idiv__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, SbVec4ui32 v) -> SbVec4ui32"""
        return _coin.SbVec4ui32___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, SbVec4ui32 v) -> SbVec4ui32"""
        return _coin.SbVec4ui32___isub__(self, *args)

    def __neg__(self):
        """__neg__(self) -> SbVec4ui32"""
        return _coin.SbVec4ui32___neg__(self)

    __swig_destroy__ = _coin.delete_SbVec4ui32
    __del__ = lambda self : None;
SbVec4ui32_swigregister = _coin.SbVec4ui32_swigregister
SbVec4ui32_swigregister(SbVec4ui32)

class SoSFVec4ui32(SoSField):
    """Proxy of C++ SoSFVec4ui32 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFVec4ui32"""
        this = _coin.new_SoSFVec4ui32()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFVec4ui32
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFVec4ui32_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFVec4ui32_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFVec4ui32_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFVec4ui32_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFVec4ui32_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SbVec4ui32"""
        return _coin.SoSFVec4ui32_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFVec4ui32 field) -> int"""
        return _coin.SoSFVec4ui32___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFVec4ui32 field) -> int"""
        return _coin.SoSFVec4ui32___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFVec4ui32_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbVec4ui32 newvalue)
        setValue(self, uint32_t x, uint32_t y, uint32_t z, uint32_t w)
        setValue(self, uint32_t xyzw)
        """
        return _coin.SoSFVec4ui32_setValue(self, *args)

SoSFVec4ui32_swigregister = _coin.SoSFVec4ui32_swigregister
SoSFVec4ui32_swigregister(SoSFVec4ui32)

def SoSFVec4ui32_createInstance():
  """SoSFVec4ui32_createInstance() -> void"""
  return _coin.SoSFVec4ui32_createInstance()

def SoSFVec4ui32_getClassTypeId():
  """SoSFVec4ui32_getClassTypeId() -> SoType"""
  return _coin.SoSFVec4ui32_getClassTypeId()

def SoSFVec4ui32_initClass():
  """SoSFVec4ui32_initClass()"""
  return _coin.SoSFVec4ui32_initClass()

class SoSFVec4f(SoSField):
    """Proxy of C++ SoSFVec4f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFVec4f"""
        this = _coin.new_SoSFVec4f()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFVec4f
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFVec4f_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFVec4f_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFVec4f_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFVec4f_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFVec4f_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SbVec4f"""
        return _coin.SoSFVec4f_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFVec4f field) -> int"""
        return _coin.SoSFVec4f___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFVec4f field) -> int"""
        return _coin.SoSFVec4f___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFVec4f_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbVec4f newvalue)
        setValue(self, float x, float y, float z, float w)
        setValue(self, float xyzw)
        setValue(self, SoSFVec4f other)
        """
        return _coin.SoSFVec4f_setValue(self, *args)

SoSFVec4f_swigregister = _coin.SoSFVec4f_swigregister
SoSFVec4f_swigregister(SoSFVec4f)

def SoSFVec4f_createInstance():
  """SoSFVec4f_createInstance() -> void"""
  return _coin.SoSFVec4f_createInstance()

def SoSFVec4f_getClassTypeId():
  """SoSFVec4f_getClassTypeId() -> SoType"""
  return _coin.SoSFVec4f_getClassTypeId()

def SoSFVec4f_initClass():
  """SoSFVec4f_initClass()"""
  return _coin.SoSFVec4f_initClass()

class SbVec4d(object):
    """Proxy of C++ SbVec4d class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbVec4d
        __init__(self, double v) -> SbVec4d
        __init__(self, double x, double y, double z, double w) -> SbVec4d
        __init__(self, SbVec4f v) -> SbVec4d
        __init__(self, SbVec4b v) -> SbVec4d
        __init__(self, SbVec4s v) -> SbVec4d
        __init__(self, SbVec4i32 v) -> SbVec4d
        """
        this = _coin.new_SbVec4d(*args)
        try: self.this.append(this)
        except: self.this = this
    def setValue(self, *args):
        """
        setValue(self, double v) -> SbVec4d
        setValue(self, double x, double y, double z, double w) -> SbVec4d
        setValue(self, SbVec4f v) -> SbVec4d
        setValue(self, SbVec4b v) -> SbVec4d
        setValue(self, SbVec4s v) -> SbVec4d
        setValue(self, SbVec4i32 v) -> SbVec4d
        """
        return _coin.SbVec4d_setValue(self, *args)

    def getValue(self):
        """getValue(self) -> double"""
        return _coin.SbVec4d_getValue(self)

    def dot(self, *args):
        """dot(self, SbVec4d v) -> double"""
        return _coin.SbVec4d_dot(self, *args)

    def equals(self, *args):
        """equals(self, SbVec4d v, double tolerance) -> SbBool"""
        return _coin.SbVec4d_equals(self, *args)

    def getReal(self, *args):
        """getReal(self, SbVec3d v)"""
        return _coin.SbVec4d_getReal(self, *args)

    def length(self):
        """length(self) -> double"""
        return _coin.SbVec4d_length(self)

    def sqrLength(self):
        """sqrLength(self) -> double"""
        return _coin.SbVec4d_sqrLength(self)

    def negate(self):
        """negate(self)"""
        return _coin.SbVec4d_negate(self)

    def normalize(self):
        """normalize(self) -> double"""
        return _coin.SbVec4d_normalize(self)

    def __imul__(self, *args):
        """__imul__(self, double d) -> SbVec4d"""
        return _coin.SbVec4d___imul__(self, *args)

    def __idiv__(self, *args):
        """__idiv__(self, double d) -> SbVec4d"""
        return _coin.SbVec4d___idiv__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, SbVec4d v) -> SbVec4d"""
        return _coin.SbVec4d___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, SbVec4d v) -> SbVec4d"""
        return _coin.SbVec4d___isub__(self, *args)

    def __neg__(self):
        """__neg__(self) -> SbVec4d"""
        return _coin.SbVec4d___neg__(self)

    def output(self, *args):
        """output(self, FILE fp)"""
        return _coin.SbVec4d_output(self, *args)

    def __add__(self, *args):
        """__add__(self, SbVec4d u) -> SbVec4d"""
        return _coin.SbVec4d___add__(self, *args)

    def __sub__(self, *args):
        """__sub__(self, SbVec4d u) -> SbVec4d"""
        return _coin.SbVec4d___sub__(self, *args)

    def __mul__(self, *args):
        """
        __mul__(self, double d) -> SbVec4d
        __mul__(self, SbDPMatrix m) -> SbVec4d
        """
        return _coin.SbVec4d___mul__(self, *args)

    def __rmul__(self, *args):
        """__rmul__(self, double d) -> SbVec4d"""
        return _coin.SbVec4d___rmul__(self, *args)

    def __div__(self, *args):
        """__div__(self, double d) -> SbVec4d"""
        return _coin.SbVec4d___div__(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SbVec4d u) -> int"""
        return _coin.SbVec4d___eq__(self, *args)

    def __nq__(self, *args):
        """__nq__(self, SbVec4d u) -> int"""
        return _coin.SbVec4d___nq__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> double"""
        return _coin.SbVec4d___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, double value)"""
        return _coin.SbVec4d___setitem__(self, *args)

    def __iter__(self):
       for i in range(4):
          yield self[i]

    def __len__(self):
          return 4

    __swig_destroy__ = _coin.delete_SbVec4d
    __del__ = lambda self : None;
SbVec4d_swigregister = _coin.SbVec4d_swigregister
SbVec4d_swigregister(SbVec4d)

class SoSFVec4d(SoSField):
    """Proxy of C++ SoSFVec4d class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSFVec4d"""
        this = _coin.new_SoSFVec4d()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSFVec4d
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoSFVec4d_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSFVec4d_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSFVec4d_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoSFVec4d_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoSFVec4d_isSame(self, *args)

    def getValue(self):
        """getValue(self) -> SbVec4d"""
        return _coin.SoSFVec4d_getValue(self)

    def __eq__(self, *args):
        """__eq__(self, SoSFVec4d field) -> int"""
        return _coin.SoSFVec4d___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoSFVec4d field) -> int"""
        return _coin.SoSFVec4d___ne__(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoSFVec4d_initClass()

    initClass = staticmethod(initClass)
    def setValue(self, *args):
        """
        setValue(self, SbVec4d newvalue)
        setValue(self, double x, double y, double z, double w)
        setValue(self, double xyzw)
        """
        return _coin.SoSFVec4d_setValue(self, *args)

SoSFVec4d_swigregister = _coin.SoSFVec4d_swigregister
SoSFVec4d_swigregister(SoSFVec4d)

def SoSFVec4d_createInstance():
  """SoSFVec4d_createInstance() -> void"""
  return _coin.SoSFVec4d_createInstance()

def SoSFVec4d_getClassTypeId():
  """SoSFVec4d_getClassTypeId() -> SoType"""
  return _coin.SoSFVec4d_getClassTypeId()

def SoSFVec4d_initClass():
  """SoSFVec4d_initClass()"""
  return _coin.SoSFVec4d_initClass()

class SoMFColor(SoMField):
    """Proxy of C++ SoMFColor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFColor"""
        this = _coin.new_SoMFColor()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFColor
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFColor_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFColor_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFColor_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFColor_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFColor_isSame(self, *args)

    def find(self, *args):
        """
        find(self, SbColor value, SbBool addifnotfound = 0) -> int
        find(self, SbColor value) -> int
        """
        return _coin.SoMFColor_find(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFColor field) -> SbBool"""
        return _coin.SoMFColor___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFColor field) -> SbBool"""
        return _coin.SoMFColor___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SbColor"""
        return _coin.SoMFColor_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFColor_finishEditing(self)

    def setValuesPointer(self, *args):
        """
        setValuesPointer(self, int num, float userdata)
        setValuesPointer(self, int num, float userdata)
        setValuesPointer(self, int num, SbColor userdata)
        setValuesPointer(self, int num, SbColor userdata)
        """
        return _coin.SoMFColor_setValuesPointer(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMFColor_initClass()

    initClass = staticmethod(initClass)
    def setValues(*args):
       if len(args) == 2:
         return _coin.SoMFColor_setValues(args[0], 0, len(args[1]), args[1])
       elif len(args) == 3:
         return _coin.SoMFColor_setValues(args[0], args[1], len(args[2]), args[2])
       return apply(_coin.SoMFColor_setValues,args)


    def setHSVValues(self, *args):
        """setHSVValues(self, int start, int num, float hsv)"""
        return _coin.SoMFColor_setHSVValues(self, *args)

    def setHSVValue(self, *args):
        """
        setHSVValue(self, float h, float s, float v)
        setHSVValue(self, float hsv)
        """
        return _coin.SoMFColor_setHSVValue(self, *args)

    def set1Value(self, *args):
        """
        set1Value(self, int idx, SbColor value)
        set1Value(self, int idx, SbVec3f vec)
        set1Value(self, int idx, float r, float g, float b)
        set1Value(self, int idx, float rgb)
        """
        return _coin.SoMFColor_set1Value(self, *args)

    def set1HSVValue(self, *args):
        """
        set1HSVValue(self, int idx, float h, float s, float v)
        set1HSVValue(self, int idx, float hsv)
        """
        return _coin.SoMFColor_set1HSVValue(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> SbColor"""
        return _coin.SoMFColor___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, int i, SbColor value)
        __setitem__(self, int i, float rgb)
        """
        return _coin.SoMFColor___setitem__(self, *args)

    def setValue(self, *args):
        """
        setValue(self, SbColor value)
        setValue(self, SbVec3f vec)
        setValue(self, float r, float g, float b)
        setValue(self, float rgb)
        setValue(self, SoMFColor other)
        """
        return _coin.SoMFColor_setValue(self, *args)

    def getValues(self, i = 0):
        """
        getValues(self, int i = 0) -> SbColor
        getValues(self) -> SbColor
        """
        return _coin.SoMFColor_getValues(self, i)

SoMFColor_swigregister = _coin.SoMFColor_swigregister
SoMFColor_swigregister(SoMFColor)

def SoMFColor_createInstance():
  """SoMFColor_createInstance() -> void"""
  return _coin.SoMFColor_createInstance()

def SoMFColor_getClassTypeId():
  """SoMFColor_getClassTypeId() -> SoType"""
  return _coin.SoMFColor_getClassTypeId()

def SoMFColor_initClass():
  """SoMFColor_initClass()"""
  return _coin.SoMFColor_initClass()

class SoMFColorRGBA(SoMField):
    """Proxy of C++ SoMFColorRGBA class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFColorRGBA"""
        this = _coin.new_SoMFColorRGBA()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFColorRGBA
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFColorRGBA_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFColorRGBA_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFColorRGBA_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFColorRGBA_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFColorRGBA_isSame(self, *args)

    def getValues(self, *args):
        """getValues(self, int start) -> SbColor4f"""
        return _coin.SoMFColorRGBA_getValues(self, *args)

    def find(self, *args):
        """
        find(self, SbColor4f value, SbBool addifnotfound = 0) -> int
        find(self, SbColor4f value) -> int
        """
        return _coin.SoMFColorRGBA_find(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFColorRGBA field) -> SbBool"""
        return _coin.SoMFColorRGBA___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFColorRGBA field) -> SbBool"""
        return _coin.SoMFColorRGBA___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SbColor4f"""
        return _coin.SoMFColorRGBA_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFColorRGBA_finishEditing(self)

    def setValuesPointer(self, *args):
        """
        setValuesPointer(self, int num, float userdata)
        setValuesPointer(self, int num, float userdata)
        setValuesPointer(self, int num, SbColor4f userdata)
        setValuesPointer(self, int num, SbColor4f userdata)
        """
        return _coin.SoMFColorRGBA_setValuesPointer(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMFColorRGBA_initClass()

    initClass = staticmethod(initClass)
    def setValues(self, *args):
        """
        setValues(self, int start, int num, SbColor4f newvals)
        setValues(self, int start, int num, float rgba)
        """
        return _coin.SoMFColorRGBA_setValues(self, *args)

    def setHSVValues(self, *args):
        """setHSVValues(self, int start, int num, float hsv)"""
        return _coin.SoMFColorRGBA_setHSVValues(self, *args)

    def setValue(self, *args):
        """
        setValue(self, SbColor4f value)
        setValue(self, SbVec4f vec)
        setValue(self, float r, float g, float b, float a)
        setValue(self, float rgba)
        """
        return _coin.SoMFColorRGBA_setValue(self, *args)

    def setHSVValue(self, *args):
        """
        setHSVValue(self, float h, float s, float v, float a)
        setHSVValue(self, float hsva)
        """
        return _coin.SoMFColorRGBA_setHSVValue(self, *args)

    def set1Value(self, *args):
        """
        set1Value(self, int idx, SbColor4f value)
        set1Value(self, int idx, SbVec4f vec)
        set1Value(self, int idx, float r, float g, float b, float a)
        set1Value(self, int idx, float rgba)
        """
        return _coin.SoMFColorRGBA_set1Value(self, *args)

    def set1HSVValue(self, *args):
        """
        set1HSVValue(self, int idx, float h, float s, float v, float a)
        set1HSVValue(self, int idx, float hsva)
        """
        return _coin.SoMFColorRGBA_set1HSVValue(self, *args)

SoMFColorRGBA_swigregister = _coin.SoMFColorRGBA_swigregister
SoMFColorRGBA_swigregister(SoMFColorRGBA)

def SoMFColorRGBA_createInstance():
  """SoMFColorRGBA_createInstance() -> void"""
  return _coin.SoMFColorRGBA_createInstance()

def SoMFColorRGBA_getClassTypeId():
  """SoMFColorRGBA_getClassTypeId() -> SoType"""
  return _coin.SoMFColorRGBA_getClassTypeId()

def SoMFColorRGBA_initClass():
  """SoMFColorRGBA_initClass()"""
  return _coin.SoMFColorRGBA_initClass()

class SoMFDouble(SoMField):
    """Proxy of C++ SoMFDouble class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFDouble"""
        this = _coin.new_SoMFDouble()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFDouble
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFDouble_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFDouble_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFDouble_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFDouble_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFDouble_isSame(self, *args)

    def getValues(self, *args):
        """getValues(self, int start) -> double"""
        return _coin.SoMFDouble_getValues(self, *args)

    def find(self, *args):
        """
        find(self, double value, SbBool addifnotfound = 0) -> int
        find(self, double value) -> int
        """
        return _coin.SoMFDouble_find(self, *args)

    def setValues(self, *args):
        """setValues(self, int start, int num, double newvals)"""
        return _coin.SoMFDouble_setValues(self, *args)

    def set1Value(self, *args):
        """set1Value(self, int idx, double value)"""
        return _coin.SoMFDouble_set1Value(self, *args)

    def setValue(self, *args):
        """setValue(self, double value)"""
        return _coin.SoMFDouble_setValue(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFDouble field) -> SbBool"""
        return _coin.SoMFDouble___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFDouble field) -> SbBool"""
        return _coin.SoMFDouble___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> double"""
        return _coin.SoMFDouble_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFDouble_finishEditing(self)

    def setValuesPointer(self, *args):
        """
        setValuesPointer(self, int num, double userdata)
        setValuesPointer(self, int num, double userdata)
        """
        return _coin.SoMFDouble_setValuesPointer(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMFDouble_initClass()

    initClass = staticmethod(initClass)
SoMFDouble_swigregister = _coin.SoMFDouble_swigregister
SoMFDouble_swigregister(SoMFDouble)

def SoMFDouble_createInstance():
  """SoMFDouble_createInstance() -> void"""
  return _coin.SoMFDouble_createInstance()

def SoMFDouble_getClassTypeId():
  """SoMFDouble_getClassTypeId() -> SoType"""
  return _coin.SoMFDouble_getClassTypeId()

def SoMFDouble_initClass():
  """SoMFDouble_initClass()"""
  return _coin.SoMFDouble_initClass()

class SoMFEngine(SoMField):
    """Proxy of C++ SoMFEngine class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFEngine"""
        this = _coin.new_SoMFEngine()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFEngine
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFEngine_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFEngine_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFEngine_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFEngine_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFEngine_isSame(self, *args)

    def find(self, *args):
        """
        find(self, SoEngine value, SbBool addifnotfound = 0) -> int
        find(self, SoEngine value) -> int
        """
        return _coin.SoMFEngine_find(self, *args)

    def setValues(*args):
       if len(args) == 2:
         return _coin.SoMFEngine_setValues(args[0], 0, len(args[1]), args[1])
       elif len(args) == 3:
         return _coin.SoMFEngine_setValues(args[0], args[1], len(args[2]), args[2])
       return apply(_coin.SoMFEngine_setValues,args)


    def set1Value(self, *args):
        """set1Value(self, int idx, SoEngine value)"""
        return _coin.SoMFEngine_set1Value(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFEngine field) -> SbBool"""
        return _coin.SoMFEngine___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFEngine field) -> SbBool"""
        return _coin.SoMFEngine___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SoEngine"""
        return _coin.SoMFEngine_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFEngine_finishEditing(self)

    def initClass():
        """initClass()"""
        return _coin.SoMFEngine_initClass()

    initClass = staticmethod(initClass)
    def fixCopy(self, *args):
        """fixCopy(self, SbBool copyconnections)"""
        return _coin.SoMFEngine_fixCopy(self, *args)

    def referencesCopy(self):
        """referencesCopy(self) -> SbBool"""
        return _coin.SoMFEngine_referencesCopy(self)

    def deleteValues(self, *args):
        """
        deleteValues(self, int start, int num = -1)
        deleteValues(self, int start)
        """
        return _coin.SoMFEngine_deleteValues(self, *args)

    def insertSpace(self, *args):
        """insertSpace(self, int start, int num)"""
        return _coin.SoMFEngine_insertSpace(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> SoEngine"""
        return _coin.SoMFEngine___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, SoEngine value)"""
        return _coin.SoMFEngine___setitem__(self, *args)

    def setValue(self, *args):
        """
        setValue(self, SoEngine value)
        setValue(self, SoMFEngine other)
        """
        return _coin.SoMFEngine_setValue(self, *args)

    def getValues(self, i = 0):
        """
        getValues(self, int i = 0) -> SoEngine
        getValues(self) -> SoEngine
        """
        return _coin.SoMFEngine_getValues(self, i)

SoMFEngine_swigregister = _coin.SoMFEngine_swigregister
SoMFEngine_swigregister(SoMFEngine)

def SoMFEngine_createInstance():
  """SoMFEngine_createInstance() -> void"""
  return _coin.SoMFEngine_createInstance()

def SoMFEngine_getClassTypeId():
  """SoMFEngine_getClassTypeId() -> SoType"""
  return _coin.SoMFEngine_getClassTypeId()

def SoMFEngine_initClass():
  """SoMFEngine_initClass()"""
  return _coin.SoMFEngine_initClass()

class SoMFBitMask(SoMFEnum):
    """Proxy of C++ SoMFBitMask class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFBitMask"""
        this = _coin.new_SoMFBitMask()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFBitMask
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFBitMask_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFBitMask_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFBitMask_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFBitMask_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFBitMask_isSame(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMFBitMask_initClass()

    initClass = staticmethod(initClass)
SoMFBitMask_swigregister = _coin.SoMFBitMask_swigregister
SoMFBitMask_swigregister(SoMFBitMask)

def SoMFBitMask_createInstance():
  """SoMFBitMask_createInstance() -> void"""
  return _coin.SoMFBitMask_createInstance()

def SoMFBitMask_getClassTypeId():
  """SoMFBitMask_getClassTypeId() -> SoType"""
  return _coin.SoMFBitMask_getClassTypeId()

def SoMFBitMask_initClass():
  """SoMFBitMask_initClass()"""
  return _coin.SoMFBitMask_initClass()

class SoMFInt32(SoMField):
    """Proxy of C++ SoMFInt32 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFInt32"""
        this = _coin.new_SoMFInt32()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFInt32
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFInt32_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFInt32_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFInt32_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFInt32_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFInt32_isSame(self, *args)

    def find(self, *args):
        """
        find(self, int32_t value, SbBool addifnotfound = 0) -> int
        find(self, int32_t value) -> int
        """
        return _coin.SoMFInt32_find(self, *args)

    def setValues(*args):
       if len(args) == 2:
          if isinstance(args[1], SoMFInt32):
             val = args[1].getValues()
             return _coin.SoMFInt32_setValues(args[0],0,len(val),val)
          else:
             return _coin.SoMFInt32_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          if isinstance(args[2], SoMFInt32):
             val = args[2].getValues()
             return _coin.SoMFInt32_setValues(args[0],args[1],len(val),val)
          else:
             return _coin.SoMFInt32_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFInt32_setValues(*args)


    def set1Value(self, *args):
        """set1Value(self, int idx, int32_t value)"""
        return _coin.SoMFInt32_set1Value(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFInt32 field) -> SbBool"""
        return _coin.SoMFInt32___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFInt32 field) -> SbBool"""
        return _coin.SoMFInt32___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> int32_t"""
        return _coin.SoMFInt32_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFInt32_finishEditing(self)

    def setValuesPointer(self, *args):
        """
        setValuesPointer(self, int num, int32_t userdata)
        setValuesPointer(self, int num, int32_t userdata)
        """
        return _coin.SoMFInt32_setValuesPointer(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMFInt32_initClass()

    initClass = staticmethod(initClass)
    def __getitem__(self, *args):
        """__getitem__(self, int i) -> int32_t"""
        return _coin.SoMFInt32___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, int32_t value)"""
        return _coin.SoMFInt32___setitem__(self, *args)

    def setValue(self, *args):
        """
        setValue(self, int32_t value)
        setValue(self, SoMFInt32 other)
        """
        return _coin.SoMFInt32_setValue(self, *args)

    def getValues(self, i = 0):
        """
        getValues(self, int32_t i = 0) -> int32_t
        getValues(self) -> int32_t
        """
        return _coin.SoMFInt32_getValues(self, i)

SoMFInt32_swigregister = _coin.SoMFInt32_swigregister
SoMFInt32_swigregister(SoMFInt32)

def SoMFInt32_createInstance():
  """SoMFInt32_createInstance() -> void"""
  return _coin.SoMFInt32_createInstance()

def SoMFInt32_getClassTypeId():
  """SoMFInt32_getClassTypeId() -> SoType"""
  return _coin.SoMFInt32_getClassTypeId()

def SoMFInt32_initClass():
  """SoMFInt32_initClass()"""
  return _coin.SoMFInt32_initClass()

class SoMFNode(SoMField):
    """Proxy of C++ SoMFNode class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFNode"""
        this = _coin.new_SoMFNode()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFNode
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFNode_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFNode_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFNode_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFNode_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFNode_isSame(self, *args)

    def find(self, *args):
        """
        find(self, SoNode value, SbBool addifnotfound = 0) -> int
        find(self, SoNode value) -> int
        """
        return _coin.SoMFNode_find(self, *args)

    def setValues(*args):
       if len(args) == 2:
         return _coin.SoMFNode_setValues(args[0], 0, len(args[1]), args[1])
       elif len(args) == 3:
         return _coin.SoMFNode_setValues(args[0], args[1], len(args[2]), args[2])
       return apply(_coin.SoMFNode_setValues,args)


    def set1Value(self, *args):
        """set1Value(self, int idx, SoNode value)"""
        return _coin.SoMFNode_set1Value(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFNode field) -> SbBool"""
        return _coin.SoMFNode___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFNode field) -> SbBool"""
        return _coin.SoMFNode___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SoNode"""
        return _coin.SoMFNode_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFNode_finishEditing(self)

    def initClass():
        """initClass()"""
        return _coin.SoMFNode_initClass()

    initClass = staticmethod(initClass)
    def fixCopy(self, *args):
        """fixCopy(self, SbBool copyconnections)"""
        return _coin.SoMFNode_fixCopy(self, *args)

    def referencesCopy(self):
        """referencesCopy(self) -> SbBool"""
        return _coin.SoMFNode_referencesCopy(self)

    def addNode(self, *args):
        """addNode(self, SoNode node)"""
        return _coin.SoMFNode_addNode(self, *args)

    def insertNode(self, *args):
        """insertNode(self, SoNode node, int idx)"""
        return _coin.SoMFNode_insertNode(self, *args)

    def getNode(self, *args):
        """getNode(self, int idx) -> SoNode"""
        return _coin.SoMFNode_getNode(self, *args)

    def findNode(self, *args):
        """findNode(self, SoNode node) -> int"""
        return _coin.SoMFNode_findNode(self, *args)

    def getNumNodes(self):
        """getNumNodes(self) -> int"""
        return _coin.SoMFNode_getNumNodes(self)

    def removeNode(self, *args):
        """
        removeNode(self, int index)
        removeNode(self, SoNode node)
        """
        return _coin.SoMFNode_removeNode(self, *args)

    def removeAllNodes(self):
        """removeAllNodes(self)"""
        return _coin.SoMFNode_removeAllNodes(self)

    def replaceNode(self, *args):
        """
        replaceNode(self, int idx, SoNode newnode)
        replaceNode(self, SoNode oldnode, SoNode newnode)
        """
        return _coin.SoMFNode_replaceNode(self, *args)

    def deleteValues(self, *args):
        """
        deleteValues(self, int start, int num = -1)
        deleteValues(self, int start)
        """
        return _coin.SoMFNode_deleteValues(self, *args)

    def insertSpace(self, *args):
        """insertSpace(self, int start, int num)"""
        return _coin.SoMFNode_insertSpace(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> SoNode"""
        return _coin.SoMFNode___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, SoNode value)"""
        return _coin.SoMFNode___setitem__(self, *args)

    def setValue(self, *args):
        """
        setValue(self, SoNode value)
        setValue(self, SoMFNode other)
        """
        return _coin.SoMFNode_setValue(self, *args)

    def getValues(self, i = 0):
        """
        getValues(self, int i = 0) -> SoNode
        getValues(self) -> SoNode
        """
        return _coin.SoMFNode_getValues(self, i)

SoMFNode_swigregister = _coin.SoMFNode_swigregister
SoMFNode_swigregister(SoMFNode)

def SoMFNode_createInstance():
  """SoMFNode_createInstance() -> void"""
  return _coin.SoMFNode_createInstance()

def SoMFNode_getClassTypeId():
  """SoMFNode_getClassTypeId() -> SoType"""
  return _coin.SoMFNode_getClassTypeId()

def SoMFNode_initClass():
  """SoMFNode_initClass()"""
  return _coin.SoMFNode_initClass()

class SoMFPath(SoMField):
    """Proxy of C++ SoMFPath class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFPath"""
        this = _coin.new_SoMFPath()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFPath
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFPath_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFPath_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFPath_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFPath_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFPath_isSame(self, *args)

    def find(self, *args):
        """
        find(self, SoPath value, SbBool addifnotfound = 0) -> int
        find(self, SoPath value) -> int
        """
        return _coin.SoMFPath_find(self, *args)

    def setValues(*args):
       if len(args) == 2:
         return _coin.SoMFPath_setValues(args[0], 0, len(args[1]), args[1])
       elif len(args) == 3:
         return _coin.SoMFPath_setValues(args[0], args[1], len(args[2]), args[2])
       return apply(_coin.SoMFPath_setValues,args)


    def set1Value(self, *args):
        """set1Value(self, int idx, SoPath value)"""
        return _coin.SoMFPath_set1Value(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFPath field) -> SbBool"""
        return _coin.SoMFPath___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFPath field) -> SbBool"""
        return _coin.SoMFPath___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SoPath"""
        return _coin.SoMFPath_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFPath_finishEditing(self)

    def initClass():
        """initClass()"""
        return _coin.SoMFPath_initClass()

    initClass = staticmethod(initClass)
    def notify(self, *args):
        """notify(self, SoNotList l)"""
        return _coin.SoMFPath_notify(self, *args)

    def fixCopy(self, *args):
        """fixCopy(self, SbBool copyconnections)"""
        return _coin.SoMFPath_fixCopy(self, *args)

    def referencesCopy(self):
        """referencesCopy(self) -> SbBool"""
        return _coin.SoMFPath_referencesCopy(self)

    def deleteValues(self, *args):
        """
        deleteValues(self, int start, int num = -1)
        deleteValues(self, int start)
        """
        return _coin.SoMFPath_deleteValues(self, *args)

    def insertSpace(self, *args):
        """insertSpace(self, int start, int num)"""
        return _coin.SoMFPath_insertSpace(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> SoPath"""
        return _coin.SoMFPath___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, SoPath value)"""
        return _coin.SoMFPath___setitem__(self, *args)

    def setValue(self, *args):
        """
        setValue(self, SoPath value)
        setValue(self, SoMFPath other)
        """
        return _coin.SoMFPath_setValue(self, *args)

    def getValues(self, i = 0):
        """
        getValues(self, int i = 0) -> SoPath
        getValues(self) -> SoPath
        """
        return _coin.SoMFPath_getValues(self, i)

SoMFPath_swigregister = _coin.SoMFPath_swigregister
SoMFPath_swigregister(SoMFPath)

def SoMFPath_createInstance():
  """SoMFPath_createInstance() -> void"""
  return _coin.SoMFPath_createInstance()

def SoMFPath_getClassTypeId():
  """SoMFPath_getClassTypeId() -> SoType"""
  return _coin.SoMFPath_getClassTypeId()

def SoMFPath_initClass():
  """SoMFPath_initClass()"""
  return _coin.SoMFPath_initClass()

class SoMFPlane(SoMField):
    """Proxy of C++ SoMFPlane class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFPlane"""
        this = _coin.new_SoMFPlane()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFPlane
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFPlane_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFPlane_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFPlane_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFPlane_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFPlane_isSame(self, *args)

    def find(self, *args):
        """
        find(self, SbPlane value, SbBool addifnotfound = 0) -> int
        find(self, SbPlane value) -> int
        """
        return _coin.SoMFPlane_find(self, *args)

    def setValues(*args):
       if len(args) == 2:
          return _coin.SoMFPlane_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          return _coin.SoMFPlane_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFPlane_setValues(*args)


    def set1Value(self, *args):
        """set1Value(self, int idx, SbPlane value)"""
        return _coin.SoMFPlane_set1Value(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFPlane field) -> SbBool"""
        return _coin.SoMFPlane___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFPlane field) -> SbBool"""
        return _coin.SoMFPlane___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SbPlane"""
        return _coin.SoMFPlane_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFPlane_finishEditing(self)

    def initClass():
        """initClass()"""
        return _coin.SoMFPlane_initClass()

    initClass = staticmethod(initClass)
    def __getitem__(self, *args):
        """__getitem__(self, int i) -> SbPlane"""
        return _coin.SoMFPlane___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, SbPlane value)"""
        return _coin.SoMFPlane___setitem__(self, *args)

    def getValues(self, i = 0):
        """
        getValues(self, int i = 0) -> SbPlane
        getValues(self) -> SbPlane
        """
        return _coin.SoMFPlane_getValues(self, i)

    def setValue(self, *args):
        """
        setValue(self, SbPlane value)
        setValue(self, SoMFPlane other)
        """
        return _coin.SoMFPlane_setValue(self, *args)

SoMFPlane_swigregister = _coin.SoMFPlane_swigregister
SoMFPlane_swigregister(SoMFPlane)

def SoMFPlane_createInstance():
  """SoMFPlane_createInstance() -> void"""
  return _coin.SoMFPlane_createInstance()

def SoMFPlane_getClassTypeId():
  """SoMFPlane_getClassTypeId() -> SoType"""
  return _coin.SoMFPlane_getClassTypeId()

def SoMFPlane_initClass():
  """SoMFPlane_initClass()"""
  return _coin.SoMFPlane_initClass()

class SoMFShort(SoMField):
    """Proxy of C++ SoMFShort class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFShort"""
        this = _coin.new_SoMFShort()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFShort
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFShort_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFShort_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFShort_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFShort_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFShort_isSame(self, *args)

    def find(self, *args):
        """
        find(self, short value, SbBool addifnotfound = 0) -> int
        find(self, short value) -> int
        """
        return _coin.SoMFShort_find(self, *args)

    def setValues(*args):
       if len(args) == 2:
          return _coin.SoMFShort_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          return _coin.SoMFShort_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFShort_setValues(*args)


    def set1Value(self, *args):
        """set1Value(self, int idx, short value)"""
        return _coin.SoMFShort_set1Value(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFShort field) -> SbBool"""
        return _coin.SoMFShort___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFShort field) -> SbBool"""
        return _coin.SoMFShort___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> short"""
        return _coin.SoMFShort_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFShort_finishEditing(self)

    def setValuesPointer(self, *args):
        """
        setValuesPointer(self, int num, short userdata)
        setValuesPointer(self, int num, short userdata)
        """
        return _coin.SoMFShort_setValuesPointer(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMFShort_initClass()

    initClass = staticmethod(initClass)
    def __getitem__(self, *args):
        """__getitem__(self, int i) -> short"""
        return _coin.SoMFShort___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, short value)"""
        return _coin.SoMFShort___setitem__(self, *args)

    def setValue(self, *args):
        """
        setValue(self, short value)
        setValue(self, SoMFShort other)
        """
        return _coin.SoMFShort_setValue(self, *args)

    def getValues(self, i = 0):
        """
        getValues(self, int i = 0) -> short
        getValues(self) -> short
        """
        return _coin.SoMFShort_getValues(self, i)

SoMFShort_swigregister = _coin.SoMFShort_swigregister
SoMFShort_swigregister(SoMFShort)

def SoMFShort_createInstance():
  """SoMFShort_createInstance() -> void"""
  return _coin.SoMFShort_createInstance()

def SoMFShort_getClassTypeId():
  """SoMFShort_getClassTypeId() -> SoType"""
  return _coin.SoMFShort_getClassTypeId()

def SoMFShort_initClass():
  """SoMFShort_initClass()"""
  return _coin.SoMFShort_initClass()

class SoMFTime(SoMField):
    """Proxy of C++ SoMFTime class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFTime"""
        this = _coin.new_SoMFTime()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFTime
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFTime_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFTime_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFTime_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFTime_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFTime_isSame(self, *args)

    def find(self, *args):
        """
        find(self, SbTime value, SbBool addifnotfound = 0) -> int
        find(self, SbTime value) -> int
        """
        return _coin.SoMFTime_find(self, *args)

    def setValues(*args):
       if len(args) == 2:
          return _coin.SoMFTime_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          return _coin.SoMFTime_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFTime_setValues(*args)


    def set1Value(self, *args):
        """set1Value(self, int idx, SbTime value)"""
        return _coin.SoMFTime_set1Value(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFTime field) -> SbBool"""
        return _coin.SoMFTime___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFTime field) -> SbBool"""
        return _coin.SoMFTime___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SbTime"""
        return _coin.SoMFTime_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFTime_finishEditing(self)

    def initClass():
        """initClass()"""
        return _coin.SoMFTime_initClass()

    initClass = staticmethod(initClass)
    def __getitem__(self, *args):
        """__getitem__(self, int i) -> SbTime"""
        return _coin.SoMFTime___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, SbTime value)"""
        return _coin.SoMFTime___setitem__(self, *args)

    def getValues(self, i = 0):
        """
        getValues(self, int i = 0) -> SbTime
        getValues(self) -> SbTime
        """
        return _coin.SoMFTime_getValues(self, i)

    def setValue(self, *args):
        """
        setValue(self, SbTime value)
        setValue(self, SoMFTime other)
        """
        return _coin.SoMFTime_setValue(self, *args)

SoMFTime_swigregister = _coin.SoMFTime_swigregister
SoMFTime_swigregister(SoMFTime)

def SoMFTime_createInstance():
  """SoMFTime_createInstance() -> void"""
  return _coin.SoMFTime_createInstance()

def SoMFTime_getClassTypeId():
  """SoMFTime_getClassTypeId() -> SoType"""
  return _coin.SoMFTime_getClassTypeId()

def SoMFTime_initClass():
  """SoMFTime_initClass()"""
  return _coin.SoMFTime_initClass()

class SoMFUInt32(SoMField):
    """Proxy of C++ SoMFUInt32 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFUInt32"""
        this = _coin.new_SoMFUInt32()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFUInt32
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFUInt32_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFUInt32_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFUInt32_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFUInt32_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFUInt32_isSame(self, *args)

    def find(self, *args):
        """
        find(self, uint32_t value, SbBool addifnotfound = 0) -> int
        find(self, uint32_t value) -> int
        """
        return _coin.SoMFUInt32_find(self, *args)

    def setValues(*args):
       if len(args) == 2:
          if isinstance(args[1], SoMFUInt32):
             val = args[1].getValues()
             return _coin.SoMFUInt32_setValues(args[0],0,len(val),val)
          else:
             return _coin.SoMFUInt32_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          if isinstance(args[2], SoMFUInt32):
             val = args[2].getValues()
             return _coin.SoMFUInt32_setValues(args[0],args[1],len(val),val)
          else:
             return _coin.SoMFUInt32_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFUInt32_setValues(*args)


    def set1Value(self, *args):
        """set1Value(self, int idx, uint32_t value)"""
        return _coin.SoMFUInt32_set1Value(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFUInt32 field) -> SbBool"""
        return _coin.SoMFUInt32___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFUInt32 field) -> SbBool"""
        return _coin.SoMFUInt32___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> uint32_t"""
        return _coin.SoMFUInt32_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFUInt32_finishEditing(self)

    def setValuesPointer(self, *args):
        """
        setValuesPointer(self, int num, uint32_t userdata)
        setValuesPointer(self, int num, uint32_t userdata)
        """
        return _coin.SoMFUInt32_setValuesPointer(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMFUInt32_initClass()

    initClass = staticmethod(initClass)
    def __getitem__(self, *args):
        """__getitem__(self, int i) -> uint32_t"""
        return _coin.SoMFUInt32___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, uint32_t value)"""
        return _coin.SoMFUInt32___setitem__(self, *args)

    def setValue(self, *args):
        """
        setValue(self, uint32_t value)
        setValue(self, SoMFUInt32 other)
        """
        return _coin.SoMFUInt32_setValue(self, *args)

    def getValues(self, i = 0):
        """
        getValues(self, int i = 0) -> uint32_t
        getValues(self) -> uint32_t
        """
        return _coin.SoMFUInt32_getValues(self, i)

SoMFUInt32_swigregister = _coin.SoMFUInt32_swigregister
SoMFUInt32_swigregister(SoMFUInt32)

def SoMFUInt32_createInstance():
  """SoMFUInt32_createInstance() -> void"""
  return _coin.SoMFUInt32_createInstance()

def SoMFUInt32_getClassTypeId():
  """SoMFUInt32_getClassTypeId() -> SoType"""
  return _coin.SoMFUInt32_getClassTypeId()

def SoMFUInt32_initClass():
  """SoMFUInt32_initClass()"""
  return _coin.SoMFUInt32_initClass()

class SoMFUShort(SoMField):
    """Proxy of C++ SoMFUShort class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFUShort"""
        this = _coin.new_SoMFUShort()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFUShort
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFUShort_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFUShort_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFUShort_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFUShort_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFUShort_isSame(self, *args)

    def find(self, *args):
        """
        find(self, unsigned short value, SbBool addifnotfound = 0) -> int
        find(self, unsigned short value) -> int
        """
        return _coin.SoMFUShort_find(self, *args)

    def setValues(*args):
       if len(args) == 2:
          return _coin.SoMFUShort_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          return _coin.SoMFUShort_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFUShort_setValues(*args)


    def set1Value(self, *args):
        """set1Value(self, int idx, unsigned short value)"""
        return _coin.SoMFUShort_set1Value(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFUShort field) -> SbBool"""
        return _coin.SoMFUShort___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFUShort field) -> SbBool"""
        return _coin.SoMFUShort___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> unsigned short"""
        return _coin.SoMFUShort_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFUShort_finishEditing(self)

    def setValuesPointer(self, *args):
        """
        setValuesPointer(self, int num, unsigned short userdata)
        setValuesPointer(self, int num, unsigned short userdata)
        """
        return _coin.SoMFUShort_setValuesPointer(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMFUShort_initClass()

    initClass = staticmethod(initClass)
    def __getitem__(self, *args):
        """__getitem__(self, int i) -> short"""
        return _coin.SoMFUShort___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, short value)"""
        return _coin.SoMFUShort___setitem__(self, *args)

    def setValue(self, *args):
        """
        setValue(self, unsigned short value)
        setValue(self, SoMFUShort other)
        """
        return _coin.SoMFUShort_setValue(self, *args)

    def getValues(self, i = 0):
        """
        getValues(self, int i = 0) -> unsigned short
        getValues(self) -> unsigned short
        """
        return _coin.SoMFUShort_getValues(self, i)

SoMFUShort_swigregister = _coin.SoMFUShort_swigregister
SoMFUShort_swigregister(SoMFUShort)

def SoMFUShort_createInstance():
  """SoMFUShort_createInstance() -> void"""
  return _coin.SoMFUShort_createInstance()

def SoMFUShort_getClassTypeId():
  """SoMFUShort_getClassTypeId() -> SoType"""
  return _coin.SoMFUShort_getClassTypeId()

def SoMFUShort_initClass():
  """SoMFUShort_initClass()"""
  return _coin.SoMFUShort_initClass()

class SoMFVec2b(SoMField):
    """Proxy of C++ SoMFVec2b class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFVec2b"""
        this = _coin.new_SoMFVec2b()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFVec2b
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFVec2b_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFVec2b_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFVec2b_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFVec2b_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFVec2b_isSame(self, *args)

    def getValues(self, *args):
        """getValues(self, int start) -> SbVec2b"""
        return _coin.SoMFVec2b_getValues(self, *args)

    def find(self, *args):
        """
        find(self, SbVec2b value, SbBool addifnotfound = 0) -> int
        find(self, SbVec2b value) -> int
        """
        return _coin.SoMFVec2b_find(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFVec2b field) -> SbBool"""
        return _coin.SoMFVec2b___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFVec2b field) -> SbBool"""
        return _coin.SoMFVec2b___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SbVec2b"""
        return _coin.SoMFVec2b_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFVec2b_finishEditing(self)

    def setValuesPointer(self, *args):
        """
        setValuesPointer(self, int num, SbVec2b userdata)
        setValuesPointer(self, int num, SbVec2b userdata)
        setValuesPointer(self, int num, int8_t userdata)
        setValuesPointer(self, int num, int8_t userdata)
        """
        return _coin.SoMFVec2b_setValuesPointer(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMFVec2b_initClass()

    initClass = staticmethod(initClass)
    def setValues(self, *args):
        """
        setValues(self, int start, int num, SbVec2b newvals)
        setValues(self, int start, int num, int8_t xy)
        """
        return _coin.SoMFVec2b_setValues(self, *args)

    def set1Value(self, *args):
        """
        set1Value(self, int idx, SbVec2b value)
        set1Value(self, int idx, int8_t x, int8_t y)
        set1Value(self, int idx, int8_t xy)
        """
        return _coin.SoMFVec2b_set1Value(self, *args)

    def setValue(self, *args):
        """
        setValue(self, SbVec2b value)
        setValue(self, int8_t x, int8_t y)
        setValue(self, int8_t xy)
        """
        return _coin.SoMFVec2b_setValue(self, *args)

SoMFVec2b_swigregister = _coin.SoMFVec2b_swigregister
SoMFVec2b_swigregister(SoMFVec2b)

def SoMFVec2b_createInstance():
  """SoMFVec2b_createInstance() -> void"""
  return _coin.SoMFVec2b_createInstance()

def SoMFVec2b_getClassTypeId():
  """SoMFVec2b_getClassTypeId() -> SoType"""
  return _coin.SoMFVec2b_getClassTypeId()

def SoMFVec2b_initClass():
  """SoMFVec2b_initClass()"""
  return _coin.SoMFVec2b_initClass()

class SoMFVec2s(SoMField):
    """Proxy of C++ SoMFVec2s class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFVec2s"""
        this = _coin.new_SoMFVec2s()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFVec2s
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFVec2s_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFVec2s_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFVec2s_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFVec2s_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFVec2s_isSame(self, *args)

    def getValues(self, *args):
        """getValues(self, int start) -> SbVec2s"""
        return _coin.SoMFVec2s_getValues(self, *args)

    def find(self, *args):
        """
        find(self, SbVec2s value, SbBool addifnotfound = 0) -> int
        find(self, SbVec2s value) -> int
        """
        return _coin.SoMFVec2s_find(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFVec2s field) -> SbBool"""
        return _coin.SoMFVec2s___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFVec2s field) -> SbBool"""
        return _coin.SoMFVec2s___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SbVec2s"""
        return _coin.SoMFVec2s_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFVec2s_finishEditing(self)

    def setValuesPointer(self, *args):
        """
        setValuesPointer(self, int num, SbVec2s userdata)
        setValuesPointer(self, int num, SbVec2s userdata)
        setValuesPointer(self, int num, short userdata)
        setValuesPointer(self, int num, short userdata)
        """
        return _coin.SoMFVec2s_setValuesPointer(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMFVec2s_initClass()

    initClass = staticmethod(initClass)
    def setValues(self, *args):
        """
        setValues(self, int start, int num, SbVec2s newvals)
        setValues(self, int start, int num, short xy)
        """
        return _coin.SoMFVec2s_setValues(self, *args)

    def set1Value(self, *args):
        """
        set1Value(self, int idx, SbVec2s value)
        set1Value(self, int idx, short x, short y)
        set1Value(self, int idx, short xy)
        """
        return _coin.SoMFVec2s_set1Value(self, *args)

    def setValue(self, *args):
        """
        setValue(self, SbVec2s value)
        setValue(self, short x, short y)
        setValue(self, short xy)
        """
        return _coin.SoMFVec2s_setValue(self, *args)

SoMFVec2s_swigregister = _coin.SoMFVec2s_swigregister
SoMFVec2s_swigregister(SoMFVec2s)

def SoMFVec2s_createInstance():
  """SoMFVec2s_createInstance() -> void"""
  return _coin.SoMFVec2s_createInstance()

def SoMFVec2s_getClassTypeId():
  """SoMFVec2s_getClassTypeId() -> SoType"""
  return _coin.SoMFVec2s_getClassTypeId()

def SoMFVec2s_initClass():
  """SoMFVec2s_initClass()"""
  return _coin.SoMFVec2s_initClass()

class SoMFVec2i32(SoMField):
    """Proxy of C++ SoMFVec2i32 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFVec2i32"""
        this = _coin.new_SoMFVec2i32()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFVec2i32
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFVec2i32_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFVec2i32_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFVec2i32_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFVec2i32_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFVec2i32_isSame(self, *args)

    def getValues(self, *args):
        """getValues(self, int start) -> SbVec2i32"""
        return _coin.SoMFVec2i32_getValues(self, *args)

    def find(self, *args):
        """
        find(self, SbVec2i32 value, SbBool addifnotfound = 0) -> int
        find(self, SbVec2i32 value) -> int
        """
        return _coin.SoMFVec2i32_find(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFVec2i32 field) -> SbBool"""
        return _coin.SoMFVec2i32___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFVec2i32 field) -> SbBool"""
        return _coin.SoMFVec2i32___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SbVec2i32"""
        return _coin.SoMFVec2i32_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFVec2i32_finishEditing(self)

    def setValuesPointer(self, *args):
        """
        setValuesPointer(self, int num, SbVec2i32 userdata)
        setValuesPointer(self, int num, SbVec2i32 userdata)
        setValuesPointer(self, int num, int32_t userdata)
        setValuesPointer(self, int num, int32_t userdata)
        """
        return _coin.SoMFVec2i32_setValuesPointer(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMFVec2i32_initClass()

    initClass = staticmethod(initClass)
    def setValues(self, *args):
        """
        setValues(self, int start, int num, SbVec2i32 newvals)
        setValues(self, int start, int num, int32_t xy)
        """
        return _coin.SoMFVec2i32_setValues(self, *args)

    def set1Value(self, *args):
        """
        set1Value(self, int idx, SbVec2i32 value)
        set1Value(self, int idx, int32_t x, int32_t y)
        set1Value(self, int idx, int32_t xy)
        """
        return _coin.SoMFVec2i32_set1Value(self, *args)

    def setValue(self, *args):
        """
        setValue(self, SbVec2i32 value)
        setValue(self, int32_t x, int32_t y)
        setValue(self, int32_t xy)
        """
        return _coin.SoMFVec2i32_setValue(self, *args)

SoMFVec2i32_swigregister = _coin.SoMFVec2i32_swigregister
SoMFVec2i32_swigregister(SoMFVec2i32)

def SoMFVec2i32_createInstance():
  """SoMFVec2i32_createInstance() -> void"""
  return _coin.SoMFVec2i32_createInstance()

def SoMFVec2i32_getClassTypeId():
  """SoMFVec2i32_getClassTypeId() -> SoType"""
  return _coin.SoMFVec2i32_getClassTypeId()

def SoMFVec2i32_initClass():
  """SoMFVec2i32_initClass()"""
  return _coin.SoMFVec2i32_initClass()

class SoMFVec2d(SoMField):
    """Proxy of C++ SoMFVec2d class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFVec2d"""
        this = _coin.new_SoMFVec2d()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFVec2d
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFVec2d_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFVec2d_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFVec2d_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFVec2d_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFVec2d_isSame(self, *args)

    def getValues(self, *args):
        """getValues(self, int start) -> SbVec2d"""
        return _coin.SoMFVec2d_getValues(self, *args)

    def find(self, *args):
        """
        find(self, SbVec2d value, SbBool addifnotfound = 0) -> int
        find(self, SbVec2d value) -> int
        """
        return _coin.SoMFVec2d_find(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFVec2d field) -> SbBool"""
        return _coin.SoMFVec2d___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFVec2d field) -> SbBool"""
        return _coin.SoMFVec2d___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SbVec2d"""
        return _coin.SoMFVec2d_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFVec2d_finishEditing(self)

    def setValuesPointer(self, *args):
        """
        setValuesPointer(self, int num, SbVec2d userdata)
        setValuesPointer(self, int num, SbVec2d userdata)
        setValuesPointer(self, int num, double userdata)
        setValuesPointer(self, int num, double userdata)
        """
        return _coin.SoMFVec2d_setValuesPointer(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMFVec2d_initClass()

    initClass = staticmethod(initClass)
    def setValues(self, *args):
        """
        setValues(self, int start, int num, SbVec2d newvals)
        setValues(self, int start, int num, double xy)
        """
        return _coin.SoMFVec2d_setValues(self, *args)

    def set1Value(self, *args):
        """
        set1Value(self, int idx, SbVec2d value)
        set1Value(self, int idx, double x, double y)
        set1Value(self, int idx, double xy)
        """
        return _coin.SoMFVec2d_set1Value(self, *args)

    def setValue(self, *args):
        """
        setValue(self, SbVec2d value)
        setValue(self, double x, double y)
        setValue(self, double xy)
        """
        return _coin.SoMFVec2d_setValue(self, *args)

SoMFVec2d_swigregister = _coin.SoMFVec2d_swigregister
SoMFVec2d_swigregister(SoMFVec2d)

def SoMFVec2d_createInstance():
  """SoMFVec2d_createInstance() -> void"""
  return _coin.SoMFVec2d_createInstance()

def SoMFVec2d_getClassTypeId():
  """SoMFVec2d_getClassTypeId() -> SoType"""
  return _coin.SoMFVec2d_getClassTypeId()

def SoMFVec2d_initClass():
  """SoMFVec2d_initClass()"""
  return _coin.SoMFVec2d_initClass()

class SoMFVec3b(SoMField):
    """Proxy of C++ SoMFVec3b class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFVec3b"""
        this = _coin.new_SoMFVec3b()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFVec3b
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFVec3b_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFVec3b_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFVec3b_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFVec3b_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFVec3b_isSame(self, *args)

    def getValues(self, *args):
        """getValues(self, int start) -> SbVec3b"""
        return _coin.SoMFVec3b_getValues(self, *args)

    def find(self, *args):
        """
        find(self, SbVec3b value, SbBool addifnotfound = 0) -> int
        find(self, SbVec3b value) -> int
        """
        return _coin.SoMFVec3b_find(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFVec3b field) -> SbBool"""
        return _coin.SoMFVec3b___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFVec3b field) -> SbBool"""
        return _coin.SoMFVec3b___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SbVec3b"""
        return _coin.SoMFVec3b_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFVec3b_finishEditing(self)

    def setValuesPointer(self, *args):
        """
        setValuesPointer(self, int num, SbVec3b userdata)
        setValuesPointer(self, int num, SbVec3b userdata)
        setValuesPointer(self, int num, int8_t userdata)
        setValuesPointer(self, int num, int8_t userdata)
        """
        return _coin.SoMFVec3b_setValuesPointer(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMFVec3b_initClass()

    initClass = staticmethod(initClass)
    def setValues(self, *args):
        """
        setValues(self, int start, int num, SbVec3b newvals)
        setValues(self, int start, int num, int8_t xyz)
        """
        return _coin.SoMFVec3b_setValues(self, *args)

    def set1Value(self, *args):
        """
        set1Value(self, int idx, SbVec3b value)
        set1Value(self, int idx, int8_t x, int8_t y, int8_t z)
        set1Value(self, int idx, int8_t xyz)
        """
        return _coin.SoMFVec3b_set1Value(self, *args)

    def setValue(self, *args):
        """
        setValue(self, SbVec3b value)
        setValue(self, int8_t x, int8_t y, int8_t z)
        setValue(self, int8_t xyz)
        """
        return _coin.SoMFVec3b_setValue(self, *args)

SoMFVec3b_swigregister = _coin.SoMFVec3b_swigregister
SoMFVec3b_swigregister(SoMFVec3b)

def SoMFVec3b_createInstance():
  """SoMFVec3b_createInstance() -> void"""
  return _coin.SoMFVec3b_createInstance()

def SoMFVec3b_getClassTypeId():
  """SoMFVec3b_getClassTypeId() -> SoType"""
  return _coin.SoMFVec3b_getClassTypeId()

def SoMFVec3b_initClass():
  """SoMFVec3b_initClass()"""
  return _coin.SoMFVec3b_initClass()

class SoMFVec3s(SoMField):
    """Proxy of C++ SoMFVec3s class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFVec3s"""
        this = _coin.new_SoMFVec3s()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFVec3s
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFVec3s_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFVec3s_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFVec3s_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFVec3s_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFVec3s_isSame(self, *args)

    def getValues(self, *args):
        """getValues(self, int start) -> SbVec3s"""
        return _coin.SoMFVec3s_getValues(self, *args)

    def find(self, *args):
        """
        find(self, SbVec3s value, SbBool addifnotfound = 0) -> int
        find(self, SbVec3s value) -> int
        """
        return _coin.SoMFVec3s_find(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFVec3s field) -> SbBool"""
        return _coin.SoMFVec3s___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFVec3s field) -> SbBool"""
        return _coin.SoMFVec3s___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SbVec3s"""
        return _coin.SoMFVec3s_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFVec3s_finishEditing(self)

    def setValuesPointer(self, *args):
        """
        setValuesPointer(self, int num, SbVec3s userdata)
        setValuesPointer(self, int num, SbVec3s userdata)
        setValuesPointer(self, int num, short userdata)
        setValuesPointer(self, int num, short userdata)
        """
        return _coin.SoMFVec3s_setValuesPointer(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMFVec3s_initClass()

    initClass = staticmethod(initClass)
    def setValues(self, *args):
        """
        setValues(self, int start, int num, SbVec3s newvals)
        setValues(self, int start, int num, short xyz)
        """
        return _coin.SoMFVec3s_setValues(self, *args)

    def set1Value(self, *args):
        """
        set1Value(self, int idx, SbVec3s value)
        set1Value(self, int idx, short x, short y, short z)
        set1Value(self, int idx, short xyz)
        """
        return _coin.SoMFVec3s_set1Value(self, *args)

    def setValue(self, *args):
        """
        setValue(self, SbVec3s value)
        setValue(self, short x, short y, short z)
        setValue(self, short xyz)
        """
        return _coin.SoMFVec3s_setValue(self, *args)

SoMFVec3s_swigregister = _coin.SoMFVec3s_swigregister
SoMFVec3s_swigregister(SoMFVec3s)

def SoMFVec3s_createInstance():
  """SoMFVec3s_createInstance() -> void"""
  return _coin.SoMFVec3s_createInstance()

def SoMFVec3s_getClassTypeId():
  """SoMFVec3s_getClassTypeId() -> SoType"""
  return _coin.SoMFVec3s_getClassTypeId()

def SoMFVec3s_initClass():
  """SoMFVec3s_initClass()"""
  return _coin.SoMFVec3s_initClass()

class SoMFVec3i32(SoMField):
    """Proxy of C++ SoMFVec3i32 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFVec3i32"""
        this = _coin.new_SoMFVec3i32()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFVec3i32
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFVec3i32_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFVec3i32_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFVec3i32_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFVec3i32_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFVec3i32_isSame(self, *args)

    def getValues(self, *args):
        """getValues(self, int start) -> SbVec3i32"""
        return _coin.SoMFVec3i32_getValues(self, *args)

    def find(self, *args):
        """
        find(self, SbVec3i32 value, SbBool addifnotfound = 0) -> int
        find(self, SbVec3i32 value) -> int
        """
        return _coin.SoMFVec3i32_find(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFVec3i32 field) -> SbBool"""
        return _coin.SoMFVec3i32___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFVec3i32 field) -> SbBool"""
        return _coin.SoMFVec3i32___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SbVec3i32"""
        return _coin.SoMFVec3i32_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFVec3i32_finishEditing(self)

    def setValuesPointer(self, *args):
        """
        setValuesPointer(self, int num, SbVec3i32 userdata)
        setValuesPointer(self, int num, SbVec3i32 userdata)
        setValuesPointer(self, int num, int32_t userdata)
        setValuesPointer(self, int num, int32_t userdata)
        """
        return _coin.SoMFVec3i32_setValuesPointer(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMFVec3i32_initClass()

    initClass = staticmethod(initClass)
    def setValues(self, *args):
        """
        setValues(self, int start, int num, SbVec3i32 newvals)
        setValues(self, int start, int num, int32_t xyz)
        """
        return _coin.SoMFVec3i32_setValues(self, *args)

    def set1Value(self, *args):
        """
        set1Value(self, int idx, SbVec3i32 value)
        set1Value(self, int idx, int32_t x, int32_t y, int32_t z)
        set1Value(self, int idx, int32_t xyz)
        """
        return _coin.SoMFVec3i32_set1Value(self, *args)

    def setValue(self, *args):
        """
        setValue(self, SbVec3i32 value)
        setValue(self, int32_t x, int32_t y, int32_t z)
        setValue(self, int32_t xyz)
        """
        return _coin.SoMFVec3i32_setValue(self, *args)

SoMFVec3i32_swigregister = _coin.SoMFVec3i32_swigregister
SoMFVec3i32_swigregister(SoMFVec3i32)

def SoMFVec3i32_createInstance():
  """SoMFVec3i32_createInstance() -> void"""
  return _coin.SoMFVec3i32_createInstance()

def SoMFVec3i32_getClassTypeId():
  """SoMFVec3i32_getClassTypeId() -> SoType"""
  return _coin.SoMFVec3i32_getClassTypeId()

def SoMFVec3i32_initClass():
  """SoMFVec3i32_initClass()"""
  return _coin.SoMFVec3i32_initClass()

class SoMFVec3d(SoMField):
    """Proxy of C++ SoMFVec3d class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFVec3d"""
        this = _coin.new_SoMFVec3d()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFVec3d
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFVec3d_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFVec3d_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFVec3d_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFVec3d_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFVec3d_isSame(self, *args)

    def find(self, *args):
        """
        find(self, SbVec3d value, SbBool addifnotfound = 0) -> int
        find(self, SbVec3d value) -> int
        """
        return _coin.SoMFVec3d_find(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFVec3d field) -> SbBool"""
        return _coin.SoMFVec3d___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFVec3d field) -> SbBool"""
        return _coin.SoMFVec3d___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SbVec3d"""
        return _coin.SoMFVec3d_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFVec3d_finishEditing(self)

    def setValuesPointer(self, *args):
        """
        setValuesPointer(self, int num, SbVec3d userdata)
        setValuesPointer(self, int num, SbVec3d userdata)
        setValuesPointer(self, int num, double userdata)
        setValuesPointer(self, int num, double userdata)
        """
        return _coin.SoMFVec3d_setValuesPointer(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMFVec3d_initClass()

    initClass = staticmethod(initClass)
    def setValues(*args):
       if len(args) == 2:
          return _coin.SoMFVec3d_setValues(args[0],0,len(args[1]),args[1])
       elif len(args) == 3:
          return _coin.SoMFVec3d_setValues(args[0],args[1],len(args[2]),args[2])
       return _coin.SoMFVec3d_setValues(*args)


    def set1Value(self, *args):
        """
        set1Value(self, int idx, SbVec3d value)
        set1Value(self, int idx, double x, double y, double z)
        set1Value(self, int idx, double xyz)
        """
        return _coin.SoMFVec3d_set1Value(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> SbVec3d"""
        return _coin.SoMFVec3d___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, SbVec3d value)"""
        return _coin.SoMFVec3d___setitem__(self, *args)

    def setValue(self, *args):
        """
        setValue(self, SbVec3d value)
        setValue(self, double x, double y, double z)
        setValue(self, double xyz)
        setValue(self, SoMFVec3d other)
        """
        return _coin.SoMFVec3d_setValue(self, *args)

    def getValues(self, i = 0):
        """
        getValues(self, int i = 0) -> SbVec3d
        getValues(self) -> SbVec3d
        """
        return _coin.SoMFVec3d_getValues(self, i)

SoMFVec3d_swigregister = _coin.SoMFVec3d_swigregister
SoMFVec3d_swigregister(SoMFVec3d)

def SoMFVec3d_createInstance():
  """SoMFVec3d_createInstance() -> void"""
  return _coin.SoMFVec3d_createInstance()

def SoMFVec3d_getClassTypeId():
  """SoMFVec3d_getClassTypeId() -> SoType"""
  return _coin.SoMFVec3d_getClassTypeId()

def SoMFVec3d_initClass():
  """SoMFVec3d_initClass()"""
  return _coin.SoMFVec3d_initClass()

class SoMFVec4b(SoMField):
    """Proxy of C++ SoMFVec4b class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFVec4b"""
        this = _coin.new_SoMFVec4b()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFVec4b
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFVec4b_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFVec4b_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFVec4b_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFVec4b_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFVec4b_isSame(self, *args)

    def getValues(self, *args):
        """getValues(self, int start) -> SbVec4b"""
        return _coin.SoMFVec4b_getValues(self, *args)

    def find(self, *args):
        """
        find(self, SbVec4b value, SbBool addifnotfound = 0) -> int
        find(self, SbVec4b value) -> int
        """
        return _coin.SoMFVec4b_find(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFVec4b field) -> SbBool"""
        return _coin.SoMFVec4b___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFVec4b field) -> SbBool"""
        return _coin.SoMFVec4b___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SbVec4b"""
        return _coin.SoMFVec4b_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFVec4b_finishEditing(self)

    def setValuesPointer(self, *args):
        """
        setValuesPointer(self, int num, SbVec4b userdata)
        setValuesPointer(self, int num, SbVec4b userdata)
        setValuesPointer(self, int num, int8_t userdata)
        setValuesPointer(self, int num, int8_t userdata)
        """
        return _coin.SoMFVec4b_setValuesPointer(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMFVec4b_initClass()

    initClass = staticmethod(initClass)
    def setValues(self, *args):
        """
        setValues(self, int start, int num, SbVec4b newvals)
        setValues(self, int start, int num, int8_t xyzw)
        """
        return _coin.SoMFVec4b_setValues(self, *args)

    def set1Value(self, *args):
        """
        set1Value(self, int idx, SbVec4b value)
        set1Value(self, int idx, int8_t x, int8_t y, int8_t z, int8_t w)
        set1Value(self, int idx, int8_t xyzw)
        """
        return _coin.SoMFVec4b_set1Value(self, *args)

    def setValue(self, *args):
        """
        setValue(self, SbVec4b value)
        setValue(self, int8_t x, int8_t y, int8_t z, int8_t w)
        setValue(self, int8_t xyzw)
        """
        return _coin.SoMFVec4b_setValue(self, *args)

SoMFVec4b_swigregister = _coin.SoMFVec4b_swigregister
SoMFVec4b_swigregister(SoMFVec4b)

def SoMFVec4b_createInstance():
  """SoMFVec4b_createInstance() -> void"""
  return _coin.SoMFVec4b_createInstance()

def SoMFVec4b_getClassTypeId():
  """SoMFVec4b_getClassTypeId() -> SoType"""
  return _coin.SoMFVec4b_getClassTypeId()

def SoMFVec4b_initClass():
  """SoMFVec4b_initClass()"""
  return _coin.SoMFVec4b_initClass()

class SoMFVec4ub(SoMField):
    """Proxy of C++ SoMFVec4ub class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFVec4ub"""
        this = _coin.new_SoMFVec4ub()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFVec4ub
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFVec4ub_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFVec4ub_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFVec4ub_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFVec4ub_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFVec4ub_isSame(self, *args)

    def getValues(self, *args):
        """getValues(self, int start) -> SbVec4ub"""
        return _coin.SoMFVec4ub_getValues(self, *args)

    def find(self, *args):
        """
        find(self, SbVec4ub value, SbBool addifnotfound = 0) -> int
        find(self, SbVec4ub value) -> int
        """
        return _coin.SoMFVec4ub_find(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFVec4ub field) -> SbBool"""
        return _coin.SoMFVec4ub___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFVec4ub field) -> SbBool"""
        return _coin.SoMFVec4ub___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SbVec4ub"""
        return _coin.SoMFVec4ub_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFVec4ub_finishEditing(self)

    def setValuesPointer(self, *args):
        """
        setValuesPointer(self, int num, SbVec4ub userdata)
        setValuesPointer(self, int num, SbVec4ub userdata)
        setValuesPointer(self, int num, uint8_t userdata)
        setValuesPointer(self, int num, uint8_t userdata)
        """
        return _coin.SoMFVec4ub_setValuesPointer(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMFVec4ub_initClass()

    initClass = staticmethod(initClass)
    def setValues(self, *args):
        """
        setValues(self, int start, int num, SbVec4ub newvals)
        setValues(self, int start, int num, uint8_t xyzw)
        """
        return _coin.SoMFVec4ub_setValues(self, *args)

    def set1Value(self, *args):
        """
        set1Value(self, int idx, SbVec4ub value)
        set1Value(self, int idx, uint8_t x, uint8_t y, uint8_t z, uint8_t w)
        set1Value(self, int idx, uint8_t xyzw)
        """
        return _coin.SoMFVec4ub_set1Value(self, *args)

    def setValue(self, *args):
        """
        setValue(self, SbVec4ub value)
        setValue(self, uint8_t x, uint8_t y, uint8_t z, uint8_t w)
        setValue(self, uint8_t xyzw)
        """
        return _coin.SoMFVec4ub_setValue(self, *args)

SoMFVec4ub_swigregister = _coin.SoMFVec4ub_swigregister
SoMFVec4ub_swigregister(SoMFVec4ub)

def SoMFVec4ub_createInstance():
  """SoMFVec4ub_createInstance() -> void"""
  return _coin.SoMFVec4ub_createInstance()

def SoMFVec4ub_getClassTypeId():
  """SoMFVec4ub_getClassTypeId() -> SoType"""
  return _coin.SoMFVec4ub_getClassTypeId()

def SoMFVec4ub_initClass():
  """SoMFVec4ub_initClass()"""
  return _coin.SoMFVec4ub_initClass()

class SoMFVec4s(SoMField):
    """Proxy of C++ SoMFVec4s class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFVec4s"""
        this = _coin.new_SoMFVec4s()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFVec4s
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFVec4s_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFVec4s_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFVec4s_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFVec4s_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFVec4s_isSame(self, *args)

    def getValues(self, *args):
        """getValues(self, int start) -> SbVec4s"""
        return _coin.SoMFVec4s_getValues(self, *args)

    def find(self, *args):
        """
        find(self, SbVec4s value, SbBool addifnotfound = 0) -> int
        find(self, SbVec4s value) -> int
        """
        return _coin.SoMFVec4s_find(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFVec4s field) -> SbBool"""
        return _coin.SoMFVec4s___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFVec4s field) -> SbBool"""
        return _coin.SoMFVec4s___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SbVec4s"""
        return _coin.SoMFVec4s_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFVec4s_finishEditing(self)

    def setValuesPointer(self, *args):
        """
        setValuesPointer(self, int num, SbVec4s userdata)
        setValuesPointer(self, int num, SbVec4s userdata)
        setValuesPointer(self, int num, short userdata)
        setValuesPointer(self, int num, short userdata)
        """
        return _coin.SoMFVec4s_setValuesPointer(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMFVec4s_initClass()

    initClass = staticmethod(initClass)
    def setValues(self, *args):
        """
        setValues(self, int start, int num, SbVec4s newvals)
        setValues(self, int start, int num, short xyzw)
        """
        return _coin.SoMFVec4s_setValues(self, *args)

    def set1Value(self, *args):
        """
        set1Value(self, int idx, SbVec4s value)
        set1Value(self, int idx, short x, short y, short z, short w)
        set1Value(self, int idx, short xyzw)
        """
        return _coin.SoMFVec4s_set1Value(self, *args)

    def setValue(self, *args):
        """
        setValue(self, SbVec4s value)
        setValue(self, short x, short y, short z, short w)
        setValue(self, short xyzw)
        """
        return _coin.SoMFVec4s_setValue(self, *args)

SoMFVec4s_swigregister = _coin.SoMFVec4s_swigregister
SoMFVec4s_swigregister(SoMFVec4s)

def SoMFVec4s_createInstance():
  """SoMFVec4s_createInstance() -> void"""
  return _coin.SoMFVec4s_createInstance()

def SoMFVec4s_getClassTypeId():
  """SoMFVec4s_getClassTypeId() -> SoType"""
  return _coin.SoMFVec4s_getClassTypeId()

def SoMFVec4s_initClass():
  """SoMFVec4s_initClass()"""
  return _coin.SoMFVec4s_initClass()

class SoMFVec4us(SoMField):
    """Proxy of C++ SoMFVec4us class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFVec4us"""
        this = _coin.new_SoMFVec4us()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFVec4us
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFVec4us_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFVec4us_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFVec4us_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFVec4us_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFVec4us_isSame(self, *args)

    def getValues(self, *args):
        """getValues(self, int start) -> SbVec4us"""
        return _coin.SoMFVec4us_getValues(self, *args)

    def find(self, *args):
        """
        find(self, SbVec4us value, SbBool addifnotfound = 0) -> int
        find(self, SbVec4us value) -> int
        """
        return _coin.SoMFVec4us_find(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFVec4us field) -> SbBool"""
        return _coin.SoMFVec4us___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFVec4us field) -> SbBool"""
        return _coin.SoMFVec4us___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SbVec4us"""
        return _coin.SoMFVec4us_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFVec4us_finishEditing(self)

    def setValuesPointer(self, *args):
        """
        setValuesPointer(self, int num, SbVec4us userdata)
        setValuesPointer(self, int num, SbVec4us userdata)
        setValuesPointer(self, int num, unsigned short userdata)
        setValuesPointer(self, int num, unsigned short userdata)
        """
        return _coin.SoMFVec4us_setValuesPointer(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMFVec4us_initClass()

    initClass = staticmethod(initClass)
    def setValues(self, *args):
        """
        setValues(self, int start, int num, SbVec4us newvals)
        setValues(self, int start, int num, unsigned short xyzw)
        """
        return _coin.SoMFVec4us_setValues(self, *args)

    def set1Value(self, *args):
        """
        set1Value(self, int idx, SbVec4us value)
        set1Value(self, int idx, unsigned short x, unsigned short y, unsigned short z, 
            unsigned short w)
        set1Value(self, int idx, unsigned short xyzw)
        """
        return _coin.SoMFVec4us_set1Value(self, *args)

    def setValue(self, *args):
        """
        setValue(self, SbVec4us value)
        setValue(self, unsigned short x, unsigned short y, unsigned short z, 
            unsigned short w)
        setValue(self, unsigned short xyzw)
        """
        return _coin.SoMFVec4us_setValue(self, *args)

SoMFVec4us_swigregister = _coin.SoMFVec4us_swigregister
SoMFVec4us_swigregister(SoMFVec4us)

def SoMFVec4us_createInstance():
  """SoMFVec4us_createInstance() -> void"""
  return _coin.SoMFVec4us_createInstance()

def SoMFVec4us_getClassTypeId():
  """SoMFVec4us_getClassTypeId() -> SoType"""
  return _coin.SoMFVec4us_getClassTypeId()

def SoMFVec4us_initClass():
  """SoMFVec4us_initClass()"""
  return _coin.SoMFVec4us_initClass()

class SoMFVec4i32(SoMField):
    """Proxy of C++ SoMFVec4i32 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFVec4i32"""
        this = _coin.new_SoMFVec4i32()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFVec4i32
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFVec4i32_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFVec4i32_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFVec4i32_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFVec4i32_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFVec4i32_isSame(self, *args)

    def getValues(self, *args):
        """getValues(self, int start) -> SbVec4i32"""
        return _coin.SoMFVec4i32_getValues(self, *args)

    def find(self, *args):
        """
        find(self, SbVec4i32 value, SbBool addifnotfound = 0) -> int
        find(self, SbVec4i32 value) -> int
        """
        return _coin.SoMFVec4i32_find(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFVec4i32 field) -> SbBool"""
        return _coin.SoMFVec4i32___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFVec4i32 field) -> SbBool"""
        return _coin.SoMFVec4i32___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SbVec4i32"""
        return _coin.SoMFVec4i32_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFVec4i32_finishEditing(self)

    def setValuesPointer(self, *args):
        """
        setValuesPointer(self, int num, SbVec4i32 userdata)
        setValuesPointer(self, int num, SbVec4i32 userdata)
        setValuesPointer(self, int num, int32_t userdata)
        setValuesPointer(self, int num, int32_t userdata)
        """
        return _coin.SoMFVec4i32_setValuesPointer(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMFVec4i32_initClass()

    initClass = staticmethod(initClass)
    def setValues(self, *args):
        """
        setValues(self, int start, int num, SbVec4i32 newvals)
        setValues(self, int start, int num, int32_t xyzw)
        """
        return _coin.SoMFVec4i32_setValues(self, *args)

    def set1Value(self, *args):
        """
        set1Value(self, int idx, SbVec4i32 value)
        set1Value(self, int idx, int32_t x, int32_t y, int32_t z, int32_t w)
        set1Value(self, int idx, int32_t xyzw)
        """
        return _coin.SoMFVec4i32_set1Value(self, *args)

    def setValue(self, *args):
        """
        setValue(self, SbVec4i32 value)
        setValue(self, int32_t x, int32_t y, int32_t z, int32_t w)
        setValue(self, int32_t xyzw)
        """
        return _coin.SoMFVec4i32_setValue(self, *args)

SoMFVec4i32_swigregister = _coin.SoMFVec4i32_swigregister
SoMFVec4i32_swigregister(SoMFVec4i32)

def SoMFVec4i32_createInstance():
  """SoMFVec4i32_createInstance() -> void"""
  return _coin.SoMFVec4i32_createInstance()

def SoMFVec4i32_getClassTypeId():
  """SoMFVec4i32_getClassTypeId() -> SoType"""
  return _coin.SoMFVec4i32_getClassTypeId()

def SoMFVec4i32_initClass():
  """SoMFVec4i32_initClass()"""
  return _coin.SoMFVec4i32_initClass()

class SoMFVec4ui32(SoMField):
    """Proxy of C++ SoMFVec4ui32 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFVec4ui32"""
        this = _coin.new_SoMFVec4ui32()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFVec4ui32
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFVec4ui32_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFVec4ui32_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFVec4ui32_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFVec4ui32_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFVec4ui32_isSame(self, *args)

    def getValues(self, *args):
        """getValues(self, int start) -> SbVec4ui32"""
        return _coin.SoMFVec4ui32_getValues(self, *args)

    def find(self, *args):
        """
        find(self, SbVec4ui32 value, SbBool addifnotfound = 0) -> int
        find(self, SbVec4ui32 value) -> int
        """
        return _coin.SoMFVec4ui32_find(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFVec4ui32 field) -> SbBool"""
        return _coin.SoMFVec4ui32___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFVec4ui32 field) -> SbBool"""
        return _coin.SoMFVec4ui32___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SbVec4ui32"""
        return _coin.SoMFVec4ui32_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFVec4ui32_finishEditing(self)

    def setValuesPointer(self, *args):
        """
        setValuesPointer(self, int num, SbVec4ui32 userdata)
        setValuesPointer(self, int num, SbVec4ui32 userdata)
        setValuesPointer(self, int num, uint32_t userdata)
        setValuesPointer(self, int num, uint32_t userdata)
        """
        return _coin.SoMFVec4ui32_setValuesPointer(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMFVec4ui32_initClass()

    initClass = staticmethod(initClass)
    def setValues(self, *args):
        """
        setValues(self, int start, int num, SbVec4ui32 newvals)
        setValues(self, int start, int num, uint32_t xyzw)
        """
        return _coin.SoMFVec4ui32_setValues(self, *args)

    def set1Value(self, *args):
        """
        set1Value(self, int idx, SbVec4ui32 value)
        set1Value(self, int idx, uint32_t x, uint32_t y, uint32_t z, uint32_t w)
        set1Value(self, int idx, uint32_t xyzw)
        """
        return _coin.SoMFVec4ui32_set1Value(self, *args)

    def setValue(self, *args):
        """
        setValue(self, SbVec4ui32 value)
        setValue(self, uint32_t x, uint32_t y, uint32_t z, uint32_t w)
        setValue(self, uint32_t xyzw)
        """
        return _coin.SoMFVec4ui32_setValue(self, *args)

SoMFVec4ui32_swigregister = _coin.SoMFVec4ui32_swigregister
SoMFVec4ui32_swigregister(SoMFVec4ui32)

def SoMFVec4ui32_createInstance():
  """SoMFVec4ui32_createInstance() -> void"""
  return _coin.SoMFVec4ui32_createInstance()

def SoMFVec4ui32_getClassTypeId():
  """SoMFVec4ui32_getClassTypeId() -> SoType"""
  return _coin.SoMFVec4ui32_getClassTypeId()

def SoMFVec4ui32_initClass():
  """SoMFVec4ui32_initClass()"""
  return _coin.SoMFVec4ui32_initClass()

class SoMFVec4d(SoMField):
    """Proxy of C++ SoMFVec4d class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoMFVec4d"""
        this = _coin.new_SoMFVec4d()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoMFVec4d
    __del__ = lambda self : None;
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoMFVec4d_createInstance()

    createInstance = staticmethod(createInstance)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMFVec4d_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMFVec4d_getTypeId(self)

    def copyFrom(self, *args):
        """copyFrom(self, SoField field)"""
        return _coin.SoMFVec4d_copyFrom(self, *args)

    def isSame(self, *args):
        """isSame(self, SoField field) -> SbBool"""
        return _coin.SoMFVec4d_isSame(self, *args)

    def getValues(self, *args):
        """getValues(self, int start) -> SbVec4d"""
        return _coin.SoMFVec4d_getValues(self, *args)

    def find(self, *args):
        """
        find(self, SbVec4d value, SbBool addifnotfound = 0) -> int
        find(self, SbVec4d value) -> int
        """
        return _coin.SoMFVec4d_find(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SoMFVec4d field) -> SbBool"""
        return _coin.SoMFVec4d___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SoMFVec4d field) -> SbBool"""
        return _coin.SoMFVec4d___ne__(self, *args)

    def startEditing(self):
        """startEditing(self) -> SbVec4d"""
        return _coin.SoMFVec4d_startEditing(self)

    def finishEditing(self):
        """finishEditing(self)"""
        return _coin.SoMFVec4d_finishEditing(self)

    def setValuesPointer(self, *args):
        """
        setValuesPointer(self, int num, SbVec4d userdata)
        setValuesPointer(self, int num, SbVec4d userdata)
        setValuesPointer(self, int num, double userdata)
        setValuesPointer(self, int num, double userdata)
        """
        return _coin.SoMFVec4d_setValuesPointer(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoMFVec4d_initClass()

    initClass = staticmethod(initClass)
    def setValues(self, *args):
        """
        setValues(self, int start, int num, SbVec4d newvals)
        setValues(self, int start, int num, double xyzw)
        """
        return _coin.SoMFVec4d_setValues(self, *args)

    def set1Value(self, *args):
        """
        set1Value(self, int idx, SbVec4d value)
        set1Value(self, int idx, double x, double y, double z, double w)
        set1Value(self, int idx, double xyzw)
        """
        return _coin.SoMFVec4d_set1Value(self, *args)

    def setValue(self, *args):
        """
        setValue(self, SbVec4d value)
        setValue(self, double x, double y, double z, double w)
        setValue(self, double xyzw)
        """
        return _coin.SoMFVec4d_setValue(self, *args)

SoMFVec4d_swigregister = _coin.SoMFVec4d_swigregister
SoMFVec4d_swigregister(SoMFVec4d)

def SoMFVec4d_createInstance():
  """SoMFVec4d_createInstance() -> void"""
  return _coin.SoMFVec4d_createInstance()

def SoMFVec4d_getClassTypeId():
  """SoMFVec4d_getClassTypeId() -> SoType"""
  return _coin.SoMFVec4d_getClassTypeId()

def SoMFVec4d_initClass():
  """SoMFVec4d_initClass()"""
  return _coin.SoMFVec4d_initClass()

class SbStringList(SbPList):
    """Proxy of C++ SbStringList class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbStringList
        __init__(self, int sizehint) -> SbStringList
        """
        this = _coin.new_SbStringList(*args)
        try: self.this.append(this)
        except: self.this = this
    def append(self, *args):
        """append(self, SbString string)"""
        return _coin.SbStringList_append(self, *args)

    def find(self, *args):
        """find(self, SbString string) -> int"""
        return _coin.SbStringList_find(self, *args)

    def insert(self, *args):
        """insert(self, SbString string, int insertbefore)"""
        return _coin.SbStringList_insert(self, *args)

    def getArrayPtr(self):
        """getArrayPtr(self) -> SbString"""
        return _coin.SbStringList_getArrayPtr(self)

    def __setitem__(self, *args):
        """__setitem__(self, int i, SbString value)"""
        return _coin.SbStringList___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> SbString"""
        return _coin.SbStringList___getitem__(self, *args)

    def get(self, *args):
        """get(self, int i) -> SbString"""
        return _coin.SbStringList_get(self, *args)

    __swig_destroy__ = _coin.delete_SbStringList
    __del__ = lambda self : None;
SbStringList_swigregister = _coin.SbStringList_swigregister
SbStringList_swigregister(SbStringList)

class SbVec3fList(SbPList):
    """Proxy of C++ SbVec3fList class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SbVec3fList"""
        this = _coin.new_SbVec3fList()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SbVec3fList
    __del__ = lambda self : None;
    def append(self, *args):
        """append(self, SbVec3f item)"""
        return _coin.SbVec3fList_append(self, *args)

    def insert(self, *args):
        """insert(self, SbVec3f item, int insertbefore)"""
        return _coin.SbVec3fList_insert(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, SbVec3f value)"""
        return _coin.SbVec3fList___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> SbVec3f"""
        return _coin.SbVec3fList___getitem__(self, *args)

    def get(self, *args):
        """get(self, int i) -> SbVec3f"""
        return _coin.SbVec3fList_get(self, *args)

SbVec3fList_swigregister = _coin.SbVec3fList_swigregister
SbVec3fList_swigregister(SbVec3fList)

class SoLockManager(object):
    """Proxy of C++ SoLockManager class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def SetUnlockString(*args):
        """SetUnlockString(char unlockstr)"""
        return _coin.SoLockManager_SetUnlockString(*args)

    SetUnlockString = staticmethod(SetUnlockString)
    def GetUnlockString():
        """GetUnlockString() -> char"""
        return _coin.SoLockManager_GetUnlockString()

    GetUnlockString = staticmethod(GetUnlockString)
    def __init__(self): 
        """__init__(self) -> SoLockManager"""
        this = _coin.new_SoLockManager()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoLockManager
    __del__ = lambda self : None;
SoLockManager_swigregister = _coin.SoLockManager_swigregister
SoLockManager_swigregister(SoLockManager)

def SoLockManager_SetUnlockString(*args):
  """SoLockManager_SetUnlockString(char unlockstr)"""
  return _coin.SoLockManager_SetUnlockString(*args)

def SoLockManager_GetUnlockString():
  """SoLockManager_GetUnlockString() -> char"""
  return _coin.SoLockManager_GetUnlockString()

class SoTransform(SoTransformation):
    """Proxy of C++ SoTransform class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTransform_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTransform_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTransform_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTransform"""
        this = _coin.new_SoTransform()
        try: self.this.append(this)
        except: self.this = this
    translation = _swig_property(_coin.SoTransform_translation_get, _coin.SoTransform_translation_set)
    rotation = _swig_property(_coin.SoTransform_rotation_get, _coin.SoTransform_rotation_set)
    scaleFactor = _swig_property(_coin.SoTransform_scaleFactor_get, _coin.SoTransform_scaleFactor_set)
    scaleOrientation = _swig_property(_coin.SoTransform_scaleOrientation_get, _coin.SoTransform_scaleOrientation_set)
    center = _swig_property(_coin.SoTransform_center_get, _coin.SoTransform_center_set)
    def pointAt(self, *args):
        """pointAt(self, SbVec3f frompoint, SbVec3f topoint)"""
        return _coin.SoTransform_pointAt(self, *args)

    def getScaleSpaceMatrix(self, *args):
        """getScaleSpaceMatrix(self, SbMatrix mat, SbMatrix inv)"""
        return _coin.SoTransform_getScaleSpaceMatrix(self, *args)

    def getRotationSpaceMatrix(self, *args):
        """getRotationSpaceMatrix(self, SbMatrix mat, SbMatrix inv)"""
        return _coin.SoTransform_getRotationSpaceMatrix(self, *args)

    def getTranslationSpaceMatrix(self, *args):
        """getTranslationSpaceMatrix(self, SbMatrix mat, SbMatrix inv)"""
        return _coin.SoTransform_getTranslationSpaceMatrix(self, *args)

    def multLeft(self, *args):
        """multLeft(self, SbMatrix mat)"""
        return _coin.SoTransform_multLeft(self, *args)

    def multRight(self, *args):
        """multRight(self, SbMatrix mat)"""
        return _coin.SoTransform_multRight(self, *args)

    def combineLeft(self, *args):
        """combineLeft(self, SoTransformation nodeonright)"""
        return _coin.SoTransform_combineLeft(self, *args)

    def combineRight(self, *args):
        """combineRight(self, SoTransformation nodeonleft)"""
        return _coin.SoTransform_combineRight(self, *args)

    def setMatrix(self, *args):
        """setMatrix(self, SbMatrix mat)"""
        return _coin.SoTransform_setMatrix(self, *args)

    def recenter(self, *args):
        """recenter(self, SbVec3f newcenter)"""
        return _coin.SoTransform_recenter(self, *args)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoTransform_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoTransform_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoTransform_callback(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoTransform_getBoundingBox(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoTransform_getMatrix(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoTransform_pick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoTransform_getPrimitiveCount(self, *args)

SoTransform_swigregister = _coin.SoTransform_swigregister
SoTransform_swigregister(SoTransform)

def SoTransform_getClassTypeId():
  """SoTransform_getClassTypeId() -> SoType"""
  return _coin.SoTransform_getClassTypeId()

def SoTransform_initClass():
  """SoTransform_initClass()"""
  return _coin.SoTransform_initClass()

class SoTransformManip(SoTransform):
    """Proxy of C++ SoTransformManip class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTransformManip_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTransformManip_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTransformManip_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTransformManip"""
        this = _coin.new_SoTransformManip()
        try: self.this.append(this)
        except: self.this = this
    def getDragger(self):
        """getDragger(self) -> SoDragger"""
        return _coin.SoTransformManip_getDragger(self)

    def replaceNode(self, *args):
        """replaceNode(self, SoPath p) -> SbBool"""
        return _coin.SoTransformManip_replaceNode(self, *args)

    def replaceManip(self, *args):
        """replaceManip(self, SoPath p, SoTransform newone) -> SbBool"""
        return _coin.SoTransformManip_replaceManip(self, *args)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoTransformManip_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoTransformManip_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoTransformManip_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoTransformManip_getBoundingBox(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoTransformManip_getMatrix(self, *args)

    def handleEvent(self, *args):
        """handleEvent(self, SoHandleEventAction action)"""
        return _coin.SoTransformManip_handleEvent(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoTransformManip_pick(self, *args)

    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoTransformManip_search(self, *args)

    def getChildren(self):
        """getChildren(self) -> SoChildList"""
        return _coin.SoTransformManip_getChildren(self)

SoTransformManip_swigregister = _coin.SoTransformManip_swigregister
SoTransformManip_swigregister(SoTransformManip)

def SoTransformManip_getClassTypeId():
  """SoTransformManip_getClassTypeId() -> SoType"""
  return _coin.SoTransformManip_getClassTypeId()

def SoTransformManip_initClass():
  """SoTransformManip_initClass()"""
  return _coin.SoTransformManip_initClass()

class SoCenterballManip(SoTransformManip):
    """Proxy of C++ SoCenterballManip class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoCenterballManip_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoCenterballManip_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoCenterballManip_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoCenterballManip"""
        this = _coin.new_SoCenterballManip()
        try: self.this.append(this)
        except: self.this = this
SoCenterballManip_swigregister = _coin.SoCenterballManip_swigregister
SoCenterballManip_swigregister(SoCenterballManip)

def SoCenterballManip_getClassTypeId():
  """SoCenterballManip_getClassTypeId() -> SoType"""
  return _coin.SoCenterballManip_getClassTypeId()

def SoCenterballManip_initClass():
  """SoCenterballManip_initClass()"""
  return _coin.SoCenterballManip_initClass()

class SoClipPlane(SoNode):
    """Proxy of C++ SoClipPlane class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoClipPlane_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoClipPlane_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoClipPlane_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoClipPlane"""
        this = _coin.new_SoClipPlane()
        try: self.this.append(this)
        except: self.this = this
    plane = _swig_property(_coin.SoClipPlane_plane_get, _coin.SoClipPlane_plane_set)
    on = _swig_property(_coin.SoClipPlane_on_get, _coin.SoClipPlane_on_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoClipPlane_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoClipPlane_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoClipPlane_callback(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoClipPlane_pick(self, *args)

SoClipPlane_swigregister = _coin.SoClipPlane_swigregister
SoClipPlane_swigregister(SoClipPlane)

def SoClipPlane_getClassTypeId():
  """SoClipPlane_getClassTypeId() -> SoType"""
  return _coin.SoClipPlane_getClassTypeId()

def SoClipPlane_initClass():
  """SoClipPlane_initClass()"""
  return _coin.SoClipPlane_initClass()

class SoClipPlaneManip(SoClipPlane):
    """Proxy of C++ SoClipPlaneManip class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoClipPlaneManip_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoClipPlaneManip_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoClipPlaneManip_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoClipPlaneManip"""
        this = _coin.new_SoClipPlaneManip()
        try: self.this.append(this)
        except: self.this = this
    def getDragger(self):
        """getDragger(self) -> SoDragger"""
        return _coin.SoClipPlaneManip_getDragger(self)

    def setValue(self, *args):
        """setValue(self, SbBox3f box, SbVec3f planenormal, float draggerscalefactor)"""
        return _coin.SoClipPlaneManip_setValue(self, *args)

    def replaceNode(self, *args):
        """replaceNode(self, SoPath p) -> SbBool"""
        return _coin.SoClipPlaneManip_replaceNode(self, *args)

    def replaceManip(self, *args):
        """replaceManip(self, SoPath p, SoClipPlane newone) -> SbBool"""
        return _coin.SoClipPlaneManip_replaceManip(self, *args)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoClipPlaneManip_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoClipPlaneManip_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoClipPlaneManip_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoClipPlaneManip_getBoundingBox(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoClipPlaneManip_getMatrix(self, *args)

    def handleEvent(self, *args):
        """handleEvent(self, SoHandleEventAction action)"""
        return _coin.SoClipPlaneManip_handleEvent(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoClipPlaneManip_pick(self, *args)

    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoClipPlaneManip_search(self, *args)

    def getChildren(self):
        """getChildren(self) -> SoChildList"""
        return _coin.SoClipPlaneManip_getChildren(self)

    draggerPosition = _swig_property(_coin.SoClipPlaneManip_draggerPosition_get, _coin.SoClipPlaneManip_draggerPosition_set)
SoClipPlaneManip_swigregister = _coin.SoClipPlaneManip_swigregister
SoClipPlaneManip_swigregister(SoClipPlaneManip)

def SoClipPlaneManip_getClassTypeId():
  """SoClipPlaneManip_getClassTypeId() -> SoType"""
  return _coin.SoClipPlaneManip_getClassTypeId()

def SoClipPlaneManip_initClass():
  """SoClipPlaneManip_initClass()"""
  return _coin.SoClipPlaneManip_initClass()

class SoLight(SoNode):
    """Proxy of C++ SoLight class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoLight_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoLight_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoLight_initClass()

    initClass = staticmethod(initClass)
    on = _swig_property(_coin.SoLight_on_get, _coin.SoLight_on_set)
    intensity = _swig_property(_coin.SoLight_intensity_get, _coin.SoLight_intensity_set)
    color = _swig_property(_coin.SoLight_color_get, _coin.SoLight_color_set)
    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoLight_callback(self, *args)

SoLight_swigregister = _coin.SoLight_swigregister
SoLight_swigregister(SoLight)

def SoLight_getClassTypeId():
  """SoLight_getClassTypeId() -> SoType"""
  return _coin.SoLight_getClassTypeId()

def SoLight_initClass():
  """SoLight_initClass()"""
  return _coin.SoLight_initClass()

class SoDirectionalLight(SoLight):
    """Proxy of C++ SoDirectionalLight class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoDirectionalLight_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoDirectionalLight_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoDirectionalLight_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoDirectionalLight"""
        this = _coin.new_SoDirectionalLight()
        try: self.this.append(this)
        except: self.this = this
    direction = _swig_property(_coin.SoDirectionalLight_direction_get, _coin.SoDirectionalLight_direction_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoDirectionalLight_GLRender(self, *args)

SoDirectionalLight_swigregister = _coin.SoDirectionalLight_swigregister
SoDirectionalLight_swigregister(SoDirectionalLight)

def SoDirectionalLight_getClassTypeId():
  """SoDirectionalLight_getClassTypeId() -> SoType"""
  return _coin.SoDirectionalLight_getClassTypeId()

def SoDirectionalLight_initClass():
  """SoDirectionalLight_initClass()"""
  return _coin.SoDirectionalLight_initClass()

class SoDirectionalLightManip(SoDirectionalLight):
    """Proxy of C++ SoDirectionalLightManip class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoDirectionalLightManip_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoDirectionalLightManip_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoDirectionalLightManip_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoDirectionalLightManip"""
        this = _coin.new_SoDirectionalLightManip()
        try: self.this.append(this)
        except: self.this = this
    def getDragger(self):
        """getDragger(self) -> SoDragger"""
        return _coin.SoDirectionalLightManip_getDragger(self)

    def replaceNode(self, *args):
        """replaceNode(self, SoPath path) -> SbBool"""
        return _coin.SoDirectionalLightManip_replaceNode(self, *args)

    def replaceManip(self, *args):
        """replaceManip(self, SoPath path, SoDirectionalLight newone) -> SbBool"""
        return _coin.SoDirectionalLightManip_replaceManip(self, *args)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoDirectionalLightManip_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoDirectionalLightManip_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoDirectionalLightManip_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoDirectionalLightManip_getBoundingBox(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoDirectionalLightManip_getMatrix(self, *args)

    def handleEvent(self, *args):
        """handleEvent(self, SoHandleEventAction action)"""
        return _coin.SoDirectionalLightManip_handleEvent(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoDirectionalLightManip_pick(self, *args)

    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoDirectionalLightManip_search(self, *args)

    def getChildren(self):
        """getChildren(self) -> SoChildList"""
        return _coin.SoDirectionalLightManip_getChildren(self)

SoDirectionalLightManip_swigregister = _coin.SoDirectionalLightManip_swigregister
SoDirectionalLightManip_swigregister(SoDirectionalLightManip)

def SoDirectionalLightManip_getClassTypeId():
  """SoDirectionalLightManip_getClassTypeId() -> SoType"""
  return _coin.SoDirectionalLightManip_getClassTypeId()

def SoDirectionalLightManip_initClass():
  """SoDirectionalLightManip_initClass()"""
  return _coin.SoDirectionalLightManip_initClass()

class SoHandleBoxManip(SoTransformManip):
    """Proxy of C++ SoHandleBoxManip class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoHandleBoxManip_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoHandleBoxManip_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoHandleBoxManip_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoHandleBoxManip"""
        this = _coin.new_SoHandleBoxManip()
        try: self.this.append(this)
        except: self.this = this
SoHandleBoxManip_swigregister = _coin.SoHandleBoxManip_swigregister
SoHandleBoxManip_swigregister(SoHandleBoxManip)

def SoHandleBoxManip_getClassTypeId():
  """SoHandleBoxManip_getClassTypeId() -> SoType"""
  return _coin.SoHandleBoxManip_getClassTypeId()

def SoHandleBoxManip_initClass():
  """SoHandleBoxManip_initClass()"""
  return _coin.SoHandleBoxManip_initClass()

class SoJackManip(SoTransformManip):
    """Proxy of C++ SoJackManip class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoJackManip_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoJackManip_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoJackManip_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoJackManip"""
        this = _coin.new_SoJackManip()
        try: self.this.append(this)
        except: self.this = this
SoJackManip_swigregister = _coin.SoJackManip_swigregister
SoJackManip_swigregister(SoJackManip)

def SoJackManip_getClassTypeId():
  """SoJackManip_getClassTypeId() -> SoType"""
  return _coin.SoJackManip_getClassTypeId()

def SoJackManip_initClass():
  """SoJackManip_initClass()"""
  return _coin.SoJackManip_initClass()

class SoPointLight(SoLight):
    """Proxy of C++ SoPointLight class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoPointLight_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoPointLight_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoPointLight_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoPointLight"""
        this = _coin.new_SoPointLight()
        try: self.this.append(this)
        except: self.this = this
    location = _swig_property(_coin.SoPointLight_location_get, _coin.SoPointLight_location_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoPointLight_GLRender(self, *args)

SoPointLight_swigregister = _coin.SoPointLight_swigregister
SoPointLight_swigregister(SoPointLight)

def SoPointLight_getClassTypeId():
  """SoPointLight_getClassTypeId() -> SoType"""
  return _coin.SoPointLight_getClassTypeId()

def SoPointLight_initClass():
  """SoPointLight_initClass()"""
  return _coin.SoPointLight_initClass()

class SoPointLightManip(SoPointLight):
    """Proxy of C++ SoPointLightManip class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoPointLightManip_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoPointLightManip_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoPointLightManip_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoPointLightManip"""
        this = _coin.new_SoPointLightManip()
        try: self.this.append(this)
        except: self.this = this
    def getDragger(self):
        """getDragger(self) -> SoDragger"""
        return _coin.SoPointLightManip_getDragger(self)

    def replaceNode(self, *args):
        """replaceNode(self, SoPath path) -> SbBool"""
        return _coin.SoPointLightManip_replaceNode(self, *args)

    def replaceManip(self, *args):
        """replaceManip(self, SoPath path, SoPointLight newone) -> SbBool"""
        return _coin.SoPointLightManip_replaceManip(self, *args)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoPointLightManip_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoPointLightManip_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoPointLightManip_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoPointLightManip_getBoundingBox(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoPointLightManip_getMatrix(self, *args)

    def handleEvent(self, *args):
        """handleEvent(self, SoHandleEventAction action)"""
        return _coin.SoPointLightManip_handleEvent(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoPointLightManip_pick(self, *args)

    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoPointLightManip_search(self, *args)

    def getChildren(self):
        """getChildren(self) -> SoChildList"""
        return _coin.SoPointLightManip_getChildren(self)

SoPointLightManip_swigregister = _coin.SoPointLightManip_swigregister
SoPointLightManip_swigregister(SoPointLightManip)

def SoPointLightManip_getClassTypeId():
  """SoPointLightManip_getClassTypeId() -> SoType"""
  return _coin.SoPointLightManip_getClassTypeId()

def SoPointLightManip_initClass():
  """SoPointLightManip_initClass()"""
  return _coin.SoPointLightManip_initClass()

class SoSpotLight(SoLight):
    """Proxy of C++ SoSpotLight class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSpotLight_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSpotLight_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoSpotLight_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoSpotLight"""
        this = _coin.new_SoSpotLight()
        try: self.this.append(this)
        except: self.this = this
    location = _swig_property(_coin.SoSpotLight_location_get, _coin.SoSpotLight_location_set)
    direction = _swig_property(_coin.SoSpotLight_direction_get, _coin.SoSpotLight_direction_set)
    dropOffRate = _swig_property(_coin.SoSpotLight_dropOffRate_get, _coin.SoSpotLight_dropOffRate_set)
    cutOffAngle = _swig_property(_coin.SoSpotLight_cutOffAngle_get, _coin.SoSpotLight_cutOffAngle_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoSpotLight_GLRender(self, *args)

SoSpotLight_swigregister = _coin.SoSpotLight_swigregister
SoSpotLight_swigregister(SoSpotLight)

def SoSpotLight_getClassTypeId():
  """SoSpotLight_getClassTypeId() -> SoType"""
  return _coin.SoSpotLight_getClassTypeId()

def SoSpotLight_initClass():
  """SoSpotLight_initClass()"""
  return _coin.SoSpotLight_initClass()

class SoSpotLightManip(SoSpotLight):
    """Proxy of C++ SoSpotLightManip class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSpotLightManip_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSpotLightManip_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoSpotLightManip_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoSpotLightManip"""
        this = _coin.new_SoSpotLightManip()
        try: self.this.append(this)
        except: self.this = this
    def getDragger(self):
        """getDragger(self) -> SoDragger"""
        return _coin.SoSpotLightManip_getDragger(self)

    def replaceNode(self, *args):
        """replaceNode(self, SoPath p) -> SbBool"""
        return _coin.SoSpotLightManip_replaceNode(self, *args)

    def replaceManip(self, *args):
        """replaceManip(self, SoPath p, SoSpotLight newone) -> SbBool"""
        return _coin.SoSpotLightManip_replaceManip(self, *args)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoSpotLightManip_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoSpotLightManip_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoSpotLightManip_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoSpotLightManip_getBoundingBox(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoSpotLightManip_getMatrix(self, *args)

    def handleEvent(self, *args):
        """handleEvent(self, SoHandleEventAction action)"""
        return _coin.SoSpotLightManip_handleEvent(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoSpotLightManip_pick(self, *args)

    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoSpotLightManip_search(self, *args)

    def getChildren(self):
        """getChildren(self) -> SoChildList"""
        return _coin.SoSpotLightManip_getChildren(self)

SoSpotLightManip_swigregister = _coin.SoSpotLightManip_swigregister
SoSpotLightManip_swigregister(SoSpotLightManip)

def SoSpotLightManip_getClassTypeId():
  """SoSpotLightManip_getClassTypeId() -> SoType"""
  return _coin.SoSpotLightManip_getClassTypeId()

def SoSpotLightManip_initClass():
  """SoSpotLightManip_initClass()"""
  return _coin.SoSpotLightManip_initClass()

class SoTabBoxManip(SoTransformManip):
    """Proxy of C++ SoTabBoxManip class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTabBoxManip_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTabBoxManip_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTabBoxManip_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTabBoxManip"""
        this = _coin.new_SoTabBoxManip()
        try: self.this.append(this)
        except: self.this = this
SoTabBoxManip_swigregister = _coin.SoTabBoxManip_swigregister
SoTabBoxManip_swigregister(SoTabBoxManip)

def SoTabBoxManip_getClassTypeId():
  """SoTabBoxManip_getClassTypeId() -> SoType"""
  return _coin.SoTabBoxManip_getClassTypeId()

def SoTabBoxManip_initClass():
  """SoTabBoxManip_initClass()"""
  return _coin.SoTabBoxManip_initClass()

class SoTrackballManip(SoTransformManip):
    """Proxy of C++ SoTrackballManip class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTrackballManip_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTrackballManip_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTrackballManip_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTrackballManip"""
        this = _coin.new_SoTrackballManip()
        try: self.this.append(this)
        except: self.this = this
SoTrackballManip_swigregister = _coin.SoTrackballManip_swigregister
SoTrackballManip_swigregister(SoTrackballManip)

def SoTrackballManip_getClassTypeId():
  """SoTrackballManip_getClassTypeId() -> SoType"""
  return _coin.SoTrackballManip_getClassTypeId()

def SoTrackballManip_initClass():
  """SoTrackballManip_initClass()"""
  return _coin.SoTrackballManip_initClass()

class SoTransformBoxManip(SoTransformManip):
    """Proxy of C++ SoTransformBoxManip class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTransformBoxManip_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTransformBoxManip_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTransformBoxManip_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTransformBoxManip"""
        this = _coin.new_SoTransformBoxManip()
        try: self.this.append(this)
        except: self.this = this
SoTransformBoxManip_swigregister = _coin.SoTransformBoxManip_swigregister
SoTransformBoxManip_swigregister(SoTransformBoxManip)

def SoTransformBoxManip_getClassTypeId():
  """SoTransformBoxManip_getClassTypeId() -> SoType"""
  return _coin.SoTransformBoxManip_getClassTypeId()

def SoTransformBoxManip_initClass():
  """SoTransformBoxManip_initClass()"""
  return _coin.SoTransformBoxManip_initClass()

class SoTransformerManip(SoTransformManip):
    """Proxy of C++ SoTransformerManip class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTransformerManip_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTransformerManip_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTransformerManip_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTransformerManip"""
        this = _coin.new_SoTransformerManip()
        try: self.this.append(this)
        except: self.this = this
    def isLocateHighlighting(self):
        """isLocateHighlighting(self) -> SbBool"""
        return _coin.SoTransformerManip_isLocateHighlighting(self)

    def setLocateHighlighting(self, *args):
        """setLocateHighlighting(self, SbBool onoff)"""
        return _coin.SoTransformerManip_setLocateHighlighting(self, *args)

    def unsquishKnobs(self):
        """unsquishKnobs(self)"""
        return _coin.SoTransformerManip_unsquishKnobs(self)

SoTransformerManip_swigregister = _coin.SoTransformerManip_swigregister
SoTransformerManip_swigregister(SoTransformerManip)

def SoTransformerManip_getClassTypeId():
  """SoTransformerManip_getClassTypeId() -> SoType"""
  return _coin.SoTransformerManip_getClassTypeId()

def SoTransformerManip_initClass():
  """SoTransformerManip_initClass()"""
  return _coin.SoTransformerManip_initClass()

class SoAudioDevice(object):
    """Proxy of C++ SoAudioDevice class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def instance():
        """instance() -> SoAudioDevice"""
        return _coin.SoAudioDevice_instance()

    instance = staticmethod(instance)
    def init(self, *args):
        """init(self, SbString devicetype, SbString devicename) -> SbBool"""
        return _coin.SoAudioDevice_init(self, *args)

    def enable(self):
        """enable(self) -> SbBool"""
        return _coin.SoAudioDevice_enable(self)

    def disable(self):
        """disable(self)"""
        return _coin.SoAudioDevice_disable(self)

    def isEnabled(self):
        """isEnabled(self) -> SbBool"""
        return _coin.SoAudioDevice_isEnabled(self)

    def haveSound(self):
        """haveSound(self) -> SbBool"""
        return _coin.SoAudioDevice_haveSound(self)

    def setGain(self, *args):
        """setGain(self, float gain)"""
        return _coin.SoAudioDevice_setGain(self, *args)

    def mute(self, mute = 1):
        """
        mute(self, SbBool mute = 1)
        mute(self)
        """
        return _coin.SoAudioDevice_mute(self, mute)

SoAudioDevice_swigregister = _coin.SoAudioDevice_swigregister
SoAudioDevice_swigregister(SoAudioDevice)

def SoAudioDevice_instance():
  """SoAudioDevice_instance() -> SoAudioDevice"""
  return _coin.SoAudioDevice_instance()

class SoByteStream(object):
    """Proxy of C++ SoByteStream class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoByteStream"""
        this = _coin.new_SoByteStream()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoByteStream
    __del__ = lambda self : None;
    def convert(self, *args):
        """
        convert(self, SoNode node, SbBool binary = 1)
        convert(self, SoNode node)
        convert(self, SoPath path, SbBool binary = 1)
        convert(self, SoPath path)
        convert(self, SoPathList pl, SbBool binary = 1)
        convert(self, SoPathList pl)
        """
        return _coin.SoByteStream_convert(self, *args)

    def getData(self):
        """getData(self) -> void"""
        return _coin.SoByteStream_getData(self)

    def getNumBytes(self):
        """getNumBytes(self) -> uint32_t"""
        return _coin.SoByteStream_getNumBytes(self)

    def unconvert(*args):
        """
        unconvert(SoByteStream stream) -> SoPathList
        unconvert(void data, uint32_t bytesinstream) -> SoPathList
        """
        return _coin.SoByteStream_unconvert(*args)

    unconvert = staticmethod(unconvert)
    def copy(self, *args):
        """copy(self, void d, size_t len)"""
        return _coin.SoByteStream_copy(self, *args)

    def isRawData(self):
        """isRawData(self) -> SbBool"""
        return _coin.SoByteStream_isRawData(self)

SoByteStream_swigregister = _coin.SoByteStream_swigregister
SoByteStream_swigregister(SoByteStream)

def SoByteStream_unconvert(*args):
  """
    unconvert(SoByteStream stream) -> SoPathList
    SoByteStream_unconvert(void data, uint32_t bytesinstream) -> SoPathList
    """
  return _coin.SoByteStream_unconvert(*args)

class SoContextHandler(object):
    """Proxy of C++ SoContextHandler class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def destructingContext(*args):
        """destructingContext(uint32_t contextid)"""
        return _coin.SoContextHandler_destructingContext(*args)

    destructingContext = staticmethod(destructingContext)
    def addContextDestructionCallback(*args):
        """addContextDestructionCallback(ContextDestructionCB func, void closure)"""
        return _coin.SoContextHandler_addContextDestructionCallback(*args)

    addContextDestructionCallback = staticmethod(addContextDestructionCallback)
    def removeContextDestructionCallback(*args):
        """removeContextDestructionCallback(ContextDestructionCB func, void closure)"""
        return _coin.SoContextHandler_removeContextDestructionCallback(*args)

    removeContextDestructionCallback = staticmethod(removeContextDestructionCallback)
    def __init__(self): 
        """__init__(self) -> SoContextHandler"""
        this = _coin.new_SoContextHandler()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoContextHandler
    __del__ = lambda self : None;
SoContextHandler_swigregister = _coin.SoContextHandler_swigregister
SoContextHandler_swigregister(SoContextHandler)

def SoContextHandler_destructingContext(*args):
  """SoContextHandler_destructingContext(uint32_t contextid)"""
  return _coin.SoContextHandler_destructingContext(*args)

def SoContextHandler_addContextDestructionCallback(*args):
  """SoContextHandler_addContextDestructionCallback(ContextDestructionCB func, void closure)"""
  return _coin.SoContextHandler_addContextDestructionCallback(*args)

def SoContextHandler_removeContextDestructionCallback(*args):
  """SoContextHandler_removeContextDestructionCallback(ContextDestructionCB func, void closure)"""
  return _coin.SoContextHandler_removeContextDestructionCallback(*args)

class SoGLImage(object):
    """Proxy of C++ SoGLImage class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoGLImage"""
        this = _coin.new_SoGLImage()
        try: self.this.append(this)
        except: self.this = this
    def unref(self, state = None):
        """
        unref(self, SoState state = None)
        unref(self)
        """
        return _coin.SoGLImage_unref(self, state)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLImage_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoGLImage_getTypeId(self)

    def isOfType(self, *args):
        """isOfType(self, SoType type) -> SbBool"""
        return _coin.SoGLImage_isOfType(self, *args)

    REPEAT = _coin.SoGLImage_REPEAT
    CLAMP = _coin.SoGLImage_CLAMP
    CLAMP_TO_EDGE = _coin.SoGLImage_CLAMP_TO_EDGE
    CLAMP_TO_BORDER = _coin.SoGLImage_CLAMP_TO_BORDER
    IMAGE = _coin.SoGLImage_IMAGE
    SUBIMAGE = _coin.SoGLImage_SUBIMAGE
    MIPMAP = _coin.SoGLImage_MIPMAP
    def setGLDisplayList(self, *args):
        """
        setGLDisplayList(self, SoGLDisplayList dl, SoState state, Wrap wraps = REPEAT, 
            Wrap wrapt = REPEAT, float quality = 0.5)
        setGLDisplayList(self, SoGLDisplayList dl, SoState state, Wrap wraps = REPEAT, 
            Wrap wrapt = REPEAT)
        setGLDisplayList(self, SoGLDisplayList dl, SoState state, Wrap wraps = REPEAT)
        setGLDisplayList(self, SoGLDisplayList dl, SoState state)
        """
        return _coin.SoGLImage_setGLDisplayList(self, *args)

    def setPBuffer(self, *args):
        """
        setPBuffer(self, SoState state, void context, Wrap wraps = REPEAT, Wrap wrapt = REPEAT, 
            float quality = 0.5)
        setPBuffer(self, SoState state, void context, Wrap wraps = REPEAT, Wrap wrapt = REPEAT)
        setPBuffer(self, SoState state, void context, Wrap wraps = REPEAT)
        setPBuffer(self, SoState state, void context)
        """
        return _coin.SoGLImage_setPBuffer(self, *args)

    def setData(self, *args):
        """
        setData(self, unsigned char bytes, SbVec2s size, int numcomponents, 
            Wrap wraps = REPEAT, Wrap wrapt = REPEAT, 
            float quality = 0.5, int border = 0, SoState createinstate = None)
        setData(self, unsigned char bytes, SbVec2s size, int numcomponents, 
            Wrap wraps = REPEAT, Wrap wrapt = REPEAT, 
            float quality = 0.5, int border = 0)
        setData(self, unsigned char bytes, SbVec2s size, int numcomponents, 
            Wrap wraps = REPEAT, Wrap wrapt = REPEAT, 
            float quality = 0.5)
        setData(self, unsigned char bytes, SbVec2s size, int numcomponents, 
            Wrap wraps = REPEAT, Wrap wrapt = REPEAT)
        setData(self, unsigned char bytes, SbVec2s size, int numcomponents, 
            Wrap wraps = REPEAT)
        setData(self, unsigned char bytes, SbVec2s size, int numcomponents)
        setData(self, unsigned char bytes, SbVec3s size, int numcomponents, 
            Wrap wraps = REPEAT, Wrap wrapt = REPEAT, 
            Wrap wrapr = REPEAT, float quality = 0.5, int border = 0, 
            SoState createinstate = None)
        setData(self, unsigned char bytes, SbVec3s size, int numcomponents, 
            Wrap wraps = REPEAT, Wrap wrapt = REPEAT, 
            Wrap wrapr = REPEAT, float quality = 0.5, int border = 0)
        setData(self, unsigned char bytes, SbVec3s size, int numcomponents, 
            Wrap wraps = REPEAT, Wrap wrapt = REPEAT, 
            Wrap wrapr = REPEAT, float quality = 0.5)
        setData(self, unsigned char bytes, SbVec3s size, int numcomponents, 
            Wrap wraps = REPEAT, Wrap wrapt = REPEAT, 
            Wrap wrapr = REPEAT)
        setData(self, unsigned char bytes, SbVec3s size, int numcomponents, 
            Wrap wraps = REPEAT, Wrap wrapt = REPEAT)
        setData(self, unsigned char bytes, SbVec3s size, int numcomponents, 
            Wrap wraps = REPEAT)
        setData(self, unsigned char bytes, SbVec3s size, int numcomponents)
        setData(self, SbImage image, Wrap wraps = REPEAT, Wrap wrapt = REPEAT, 
            float quality = 0.5, int border = 0, SoState createinstate = None)
        setData(self, SbImage image, Wrap wraps = REPEAT, Wrap wrapt = REPEAT, 
            float quality = 0.5, int border = 0)
        setData(self, SbImage image, Wrap wraps = REPEAT, Wrap wrapt = REPEAT, 
            float quality = 0.5)
        setData(self, SbImage image, Wrap wraps = REPEAT, Wrap wrapt = REPEAT)
        setData(self, SbImage image, Wrap wraps = REPEAT)
        setData(self, SbImage image)
        setData(self, SbImage image, Wrap wraps, Wrap wrapt, Wrap wrapr, 
            float quality = 0.5, int border = 0, SoState createinstate = None)
        setData(self, SbImage image, Wrap wraps, Wrap wrapt, Wrap wrapr, 
            float quality = 0.5, int border = 0)
        setData(self, SbImage image, Wrap wraps, Wrap wrapt, Wrap wrapr, 
            float quality = 0.5)
        setData(self, SbImage image, Wrap wraps, Wrap wrapt, Wrap wrapr)
        """
        return _coin.SoGLImage_setData(self, *args)

    SCALE_DOWN = _coin.SoGLImage_SCALE_DOWN
    NO_MIPMAP = _coin.SoGLImage_NO_MIPMAP
    LINEAR_MAG_FILTER = _coin.SoGLImage_LINEAR_MAG_FILTER
    LINEAR_MIN_FILTER = _coin.SoGLImage_LINEAR_MIN_FILTER
    LINEAR_MIPMAP_FILTER = _coin.SoGLImage_LINEAR_MIPMAP_FILTER
    FORCE_TRANSPARENCY_TRUE = _coin.SoGLImage_FORCE_TRANSPARENCY_TRUE
    FORCE_TRANSPARENCY_FALSE = _coin.SoGLImage_FORCE_TRANSPARENCY_FALSE
    FORCE_ALPHA_TEST_TRUE = _coin.SoGLImage_FORCE_ALPHA_TEST_TRUE
    FORCE_ALPHA_TEST_FALSE = _coin.SoGLImage_FORCE_ALPHA_TEST_FALSE
    INVINCIBLE = _coin.SoGLImage_INVINCIBLE
    RECTANGLE = _coin.SoGLImage_RECTANGLE
    COMPRESSED = _coin.SoGLImage_COMPRESSED
    USE_QUALITY_VALUE = _coin.SoGLImage_USE_QUALITY_VALUE
    def setFlags(self, *args):
        """setFlags(self, uint32_t flags)"""
        return _coin.SoGLImage_setFlags(self, *args)

    def getFlags(self):
        """getFlags(self) -> uint32_t"""
        return _coin.SoGLImage_getFlags(self)

    def getImage(self):
        """getImage(self) -> SbImage"""
        return _coin.SoGLImage_getImage(self)

    def getGLDisplayList(self, *args):
        """getGLDisplayList(self, SoState state) -> SoGLDisplayList"""
        return _coin.SoGLImage_getGLDisplayList(self, *args)

    def hasTransparency(self):
        """hasTransparency(self) -> SbBool"""
        return _coin.SoGLImage_hasTransparency(self)

    def useAlphaTest(self):
        """useAlphaTest(self) -> SbBool"""
        return _coin.SoGLImage_useAlphaTest(self)

    def getWrapS(self):
        """getWrapS(self) -> Wrap"""
        return _coin.SoGLImage_getWrapS(self)

    def getWrapT(self):
        """getWrapT(self) -> Wrap"""
        return _coin.SoGLImage_getWrapT(self)

    def getWrapR(self):
        """getWrapR(self) -> Wrap"""
        return _coin.SoGLImage_getWrapR(self)

    def getQuality(self):
        """getQuality(self) -> float"""
        return _coin.SoGLImage_getQuality(self)

    def getGLImageId(self):
        """getGLImageId(self) -> uint32_t"""
        return _coin.SoGLImage_getGLImageId(self)

    def beginFrame(*args):
        """beginFrame(SoState state)"""
        return _coin.SoGLImage_beginFrame(*args)

    beginFrame = staticmethod(beginFrame)
    def tagImage(*args):
        """tagImage(SoState state, SoGLImage image)"""
        return _coin.SoGLImage_tagImage(*args)

    tagImage = staticmethod(tagImage)
    def endFrame(*args):
        """endFrame(SoState state)"""
        return _coin.SoGLImage_endFrame(*args)

    endFrame = staticmethod(endFrame)
    def setDisplayListMaxAge(*args):
        """setDisplayListMaxAge(uint32_t maxage)"""
        return _coin.SoGLImage_setDisplayListMaxAge(*args)

    setDisplayListMaxAge = staticmethod(setDisplayListMaxAge)
    def freeAllImages(state = None):
        """
        freeAllImages(SoState state = None)
        freeAllImages()
        """
        return _coin.SoGLImage_freeAllImages(state)

    freeAllImages = staticmethod(freeAllImages)
    def setEndFrameCallback(self, *args):
        """setEndFrameCallback(self, void cb, void closure)"""
        return _coin.SoGLImage_setEndFrameCallback(self, *args)

    def getNumFramesSinceUsed(self):
        """getNumFramesSinceUsed(self) -> int"""
        return _coin.SoGLImage_getNumFramesSinceUsed(self)

    def initClass():
        """initClass()"""
        return _coin.SoGLImage_initClass()

    initClass = staticmethod(initClass)
    def setResizeCallback(*args):
        """setResizeCallback(SoGLImageResizeCB f, void closure)"""
        return _coin.SoGLImage_setResizeCallback(*args)

    setResizeCallback = staticmethod(setResizeCallback)
SoGLImage_swigregister = _coin.SoGLImage_swigregister
SoGLImage_swigregister(SoGLImage)

def SoGLImage_getClassTypeId():
  """SoGLImage_getClassTypeId() -> SoType"""
  return _coin.SoGLImage_getClassTypeId()

def SoGLImage_beginFrame(*args):
  """SoGLImage_beginFrame(SoState state)"""
  return _coin.SoGLImage_beginFrame(*args)

def SoGLImage_tagImage(*args):
  """SoGLImage_tagImage(SoState state, SoGLImage image)"""
  return _coin.SoGLImage_tagImage(*args)

def SoGLImage_endFrame(*args):
  """SoGLImage_endFrame(SoState state)"""
  return _coin.SoGLImage_endFrame(*args)

def SoGLImage_setDisplayListMaxAge(*args):
  """SoGLImage_setDisplayListMaxAge(uint32_t maxage)"""
  return _coin.SoGLImage_setDisplayListMaxAge(*args)

def SoGLImage_freeAllImages(state = None):
  """
    freeAllImages(SoState state = None)
    SoGLImage_freeAllImages()
    """
  return _coin.SoGLImage_freeAllImages(state)

def SoGLImage_initClass():
  """SoGLImage_initClass()"""
  return _coin.SoGLImage_initClass()

def SoGLImage_setResizeCallback(*args):
  """SoGLImage_setResizeCallback(SoGLImageResizeCB f, void closure)"""
  return _coin.SoGLImage_setResizeCallback(*args)

class SoGLBigImage(SoGLImage):
    """Proxy of C++ SoGLBigImage class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoGLBigImage"""
        this = _coin.new_SoGLBigImage()
        try: self.this.append(this)
        except: self.this = this
    def unref(self, state = None):
        """
        unref(self, SoState state = None)
        unref(self)
        """
        return _coin.SoGLBigImage_unref(self, state)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGLBigImage_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoGLBigImage_getTypeId(self)

    def setData(self, *args):
        """
        setData(self, SbImage image, Wrap wraps = REPEAT, Wrap wrapt = REPEAT, 
            float quality = 0.5, int border = 0, SoState createinstate = None)
        setData(self, SbImage image, Wrap wraps = REPEAT, Wrap wrapt = REPEAT, 
            float quality = 0.5, int border = 0)
        setData(self, SbImage image, Wrap wraps = REPEAT, Wrap wrapt = REPEAT, 
            float quality = 0.5)
        setData(self, SbImage image, Wrap wraps = REPEAT, Wrap wrapt = REPEAT)
        setData(self, SbImage image, Wrap wraps = REPEAT)
        setData(self, SbImage image)
        setData(self, SbImage image, Wrap wraps, Wrap wrapt, Wrap wrapr, 
            float quality = 0.5, int border = 0, SoState createinstate = None)
        setData(self, SbImage image, Wrap wraps, Wrap wrapt, Wrap wrapr, 
            float quality = 0.5, int border = 0)
        setData(self, SbImage image, Wrap wraps, Wrap wrapt, Wrap wrapr, 
            float quality = 0.5)
        setData(self, SbImage image, Wrap wraps, Wrap wrapt, Wrap wrapr)
        """
        return _coin.SoGLBigImage_setData(self, *args)

    def initSubImages(self, *args):
        """initSubImages(self, SbVec2s subimagesize) -> int"""
        return _coin.SoGLBigImage_initSubImages(self, *args)

    def handleSubImage(self, *args):
        """handleSubImage(self, int idx, SbVec2f start, SbVec2f end, SbVec2f tcmul)"""
        return _coin.SoGLBigImage_handleSubImage(self, *args)

    def applySubImage(self, *args):
        """applySubImage(self, SoState state, int idx, float quality, SbVec2s projsize)"""
        return _coin.SoGLBigImage_applySubImage(self, *args)

    def exceededChangeLimit(self):
        """exceededChangeLimit(self) -> SbBool"""
        return _coin.SoGLBigImage_exceededChangeLimit(self)

    def setChangeLimit(*args):
        """setChangeLimit(int limit) -> int"""
        return _coin.SoGLBigImage_setChangeLimit(*args)

    setChangeLimit = staticmethod(setChangeLimit)
    def getGLDisplayList(self, *args):
        """getGLDisplayList(self, SoState state) -> SoGLDisplayList"""
        return _coin.SoGLBigImage_getGLDisplayList(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoGLBigImage_initClass()

    initClass = staticmethod(initClass)
SoGLBigImage_swigregister = _coin.SoGLBigImage_swigregister
SoGLBigImage_swigregister(SoGLBigImage)

def SoGLBigImage_getClassTypeId():
  """SoGLBigImage_getClassTypeId() -> SoType"""
  return _coin.SoGLBigImage_getClassTypeId()

def SoGLBigImage_setChangeLimit(*args):
  """SoGLBigImage_setChangeLimit(int limit) -> int"""
  return _coin.SoGLBigImage_setChangeLimit(*args)

def SoGLBigImage_initClass():
  """SoGLBigImage_initClass()"""
  return _coin.SoGLBigImage_initClass()

class SoGlyph(object):
    """Proxy of C++ SoGlyph class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    FONT2D = _coin.SoGlyph_FONT2D
    FONT3D = _coin.SoGlyph_FONT3D
    def unref(self):
        """unref(self)"""
        return _coin.SoGlyph_unref(self)

    def getCoords(self):
        """getCoords(self) -> SbVec2f"""
        return _coin.SoGlyph_getCoords(self)

    def getFaceIndices(self):
        """getFaceIndices(self) -> int"""
        return _coin.SoGlyph_getFaceIndices(self)

    def getEdgeIndices(self):
        """getEdgeIndices(self) -> int"""
        return _coin.SoGlyph_getEdgeIndices(self)

    def getNextCWEdge(self, *args):
        """getNextCWEdge(self, int edgeidx) -> int"""
        return _coin.SoGlyph_getNextCWEdge(self, *args)

    def getNextCCWEdge(self, *args):
        """getNextCCWEdge(self, int edgeidx) -> int"""
        return _coin.SoGlyph_getNextCCWEdge(self, *args)

    def getWidth(self):
        """getWidth(self) -> float"""
        return _coin.SoGlyph_getWidth(self)

    def getBoundingBox(self):
        """getBoundingBox(self) -> SbBox2f"""
        return _coin.SoGlyph_getBoundingBox(self)

    def getGlyph(*args):
        """
        getGlyph(char character, SbName font) -> SoGlyph
        getGlyph(SoState state, unsigned int character, SbVec2s size, 
            float angle) -> SoGlyph
        """
        return _coin.SoGlyph_getGlyph(*args)

    getGlyph = staticmethod(getGlyph)
    def getAdvance(self):
        """getAdvance(self) -> SbVec2s"""
        return _coin.SoGlyph_getAdvance(self)

    def getKerning(self, *args):
        """getKerning(self, SoGlyph rightglyph) -> SbVec2s"""
        return _coin.SoGlyph_getKerning(self, *args)

    def getBitmap(self, *args):
        """getBitmap(self, SbVec2s size, SbVec2s pos, SbBool antialiased) -> unsigned char"""
        return _coin.SoGlyph_getBitmap(self, *args)

SoGlyph_swigregister = _coin.SoGlyph_swigregister
SoGlyph_swigregister(SoGlyph)

def SoGlyph_getGlyph(*args):
  """
    getGlyph(char character, SbName font) -> SoGlyph
    SoGlyph_getGlyph(SoState state, unsigned int character, SbVec2s size, 
        float angle) -> SoGlyph
    """
  return _coin.SoGlyph_getGlyph(*args)

class SoProto(SoNode):
    """Proxy of C++ SoProto class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, externproto = 0): 
        """
        __init__(self, SbBool externproto = 0) -> SoProto
        __init__(self) -> SoProto
        """
        this = _coin.new_SoProto(externproto)
        try: self.this.append(this)
        except: self.this = this
    def setFetchExternProtoCallback(*args):
        """setFetchExternProtoCallback(SoFetchExternProtoCB cb, void closure)"""
        return _coin.SoProto_setFetchExternProtoCallback(*args)

    setFetchExternProtoCallback = staticmethod(setFetchExternProtoCallback)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoProto_getTypeId(self)

    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoProto_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def findProto(*args):
        """findProto(SbName name) -> SoProto"""
        return _coin.SoProto_findProto(*args)

    findProto = staticmethod(findProto)
    def initClass():
        """initClass()"""
        return _coin.SoProto_initClass()

    initClass = staticmethod(initClass)
    def createProtoInstance(self):
        """createProtoInstance(self) -> SoProtoInstance"""
        return _coin.SoProto_createProtoInstance(self)

    def addISReference(self, *args):
        """addISReference(self, SoNode container, SbName fieldname, SbName interfacename)"""
        return _coin.SoProto_addISReference(self, *args)

    def findISReference(self, *args):
        """findISReference(self, SoFieldContainer container, SbName fieldname) -> SbName"""
        return _coin.SoProto_findISReference(self, *args)

    def addReference(self, *args):
        """addReference(self, SbName name, SoBase base)"""
        return _coin.SoProto_addReference(self, *args)

    def removeReference(self, *args):
        """removeReference(self, SbName name)"""
        return _coin.SoProto_removeReference(self, *args)

    def findReference(self, *args):
        """findReference(self, SbName name) -> SoBase"""
        return _coin.SoProto_findReference(self, *args)

    def addRoute(self, *args):
        """addRoute(self, SbName fromnode, SbName fromfield, SbName tonode, SbName tofield)"""
        return _coin.SoProto_addRoute(self, *args)

    def getProtoName(self):
        """getProtoName(self) -> SbName"""
        return _coin.SoProto_getProtoName(self)

    def readInstance(self, *args):
        """readInstance(self, SoInput input, unsigned short flags) -> SbBool"""
        return _coin.SoProto_readInstance(self, *args)

    def write(self, *args):
        """write(self, SoWriteAction action)"""
        return _coin.SoProto_write(self, *args)

SoProto_swigregister = _coin.SoProto_swigregister
SoProto_swigregister(SoProto)

def SoProto_setFetchExternProtoCallback(*args):
  """SoProto_setFetchExternProtoCallback(SoFetchExternProtoCB cb, void closure)"""
  return _coin.SoProto_setFetchExternProtoCallback(*args)

def SoProto_getClassTypeId():
  """SoProto_getClassTypeId() -> SoType"""
  return _coin.SoProto_getClassTypeId()

def SoProto_findProto(*args):
  """SoProto_findProto(SbName name) -> SoProto"""
  return _coin.SoProto_findProto(*args)

def SoProto_initClass():
  """SoProto_initClass()"""
  return _coin.SoProto_initClass()

class SoProtoInstance(SoNode):
    """Proxy of C++ SoProtoInstance class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoProtoInstance_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoProtoInstance_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoProtoInstance_initClass()

    initClass = staticmethod(initClass)
    def __init__(self, *args): 
        """__init__(self, SoProto proto, SoFieldData deffielddata) -> SoProtoInstance"""
        this = _coin.new_SoProtoInstance(*args)
        try: self.this.append(this)
        except: self.this = this
    def findProtoInstance(*args):
        """findProtoInstance(SoNode rootnode) -> SoProtoInstance"""
        return _coin.SoProtoInstance_findProtoInstance(*args)

    findProtoInstance = staticmethod(findProtoInstance)
    def setRootNode(self, *args):
        """setRootNode(self, SoNode root)"""
        return _coin.SoProtoInstance_setRootNode(self, *args)

    def getRootNode(self):
        """getRootNode(self) -> SoNode"""
        return _coin.SoProtoInstance_getRootNode(self)

    def getProtoDefinition(self):
        """getProtoDefinition(self) -> SoProto"""
        return _coin.SoProtoInstance_getProtoDefinition(self)

    def getProtoName(self):
        """getProtoName(self) -> SbName"""
        return _coin.SoProtoInstance_getProtoName(self)

    def write(self, *args):
        """write(self, SoWriteAction action)"""
        return _coin.SoProtoInstance_write(self, *args)

SoProtoInstance_swigregister = _coin.SoProtoInstance_swigregister
SoProtoInstance_swigregister(SoProtoInstance)

def SoProtoInstance_getClassTypeId():
  """SoProtoInstance_getClassTypeId() -> SoType"""
  return _coin.SoProtoInstance_getClassTypeId()

def SoProtoInstance_initClass():
  """SoProtoInstance_initClass()"""
  return _coin.SoProtoInstance_initClass()

def SoProtoInstance_findProtoInstance(*args):
  """SoProtoInstance_findProtoInstance(SoNode rootnode) -> SoProtoInstance"""
  return _coin.SoProtoInstance_findProtoInstance(*args)

class SoTranReceiver(object):
    """Proxy of C++ SoTranReceiver class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, SoGroup root) -> SoTranReceiver"""
        this = _coin.new_SoTranReceiver(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoTranReceiver
    __del__ = lambda self : None;
    def interpret(self, *args):
        """interpret(self, SoInput input) -> SbBool"""
        return _coin.SoTranReceiver_interpret(self, *args)

SoTranReceiver_swigregister = _coin.SoTranReceiver_swigregister
SoTranReceiver_swigregister(SoTranReceiver)

class SoTranSender(object):
    """Proxy of C++ SoTranSender class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, SoOutput output) -> SoTranSender"""
        this = _coin.new_SoTranSender(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoTranSender
    __del__ = lambda self : None;
    def getOutput(self):
        """getOutput(self) -> SoOutput"""
        return _coin.SoTranSender_getOutput(self)

    def insert(self, *args):
        """
        insert(self, SoNode node)
        insert(self, SoNode node, SoNode parent, int n)
        """
        return _coin.SoTranSender_insert(self, *args)

    def remove(self, *args):
        """remove(self, SoNode parent, int n)"""
        return _coin.SoTranSender_remove(self, *args)

    def replace(self, *args):
        """replace(self, SoNode parent, int n, SoNode newnode)"""
        return _coin.SoTranSender_replace(self, *args)

    def modify(self, *args):
        """modify(self, SoNode node)"""
        return _coin.SoTranSender_modify(self, *args)

    def prepareToSend(self):
        """prepareToSend(self)"""
        return _coin.SoTranSender_prepareToSend(self)

SoTranSender_swigregister = _coin.SoTranSender_swigregister
SoTranSender_swigregister(SoTranSender)

class SoAppearanceKit(SoBaseKit):
    """Proxy of C++ SoAppearanceKit class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoAppearanceKit_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoAppearanceKit_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoAppearanceKit_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoAppearanceKit_getNodekitCatalog(self)

    def __init__(self): 
        """__init__(self) -> SoAppearanceKit"""
        this = _coin.new_SoAppearanceKit()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoAppearanceKit_initClass()

    initClass = staticmethod(initClass)
SoAppearanceKit_swigregister = _coin.SoAppearanceKit_swigregister
SoAppearanceKit_swigregister(SoAppearanceKit)

def SoAppearanceKit_getClassTypeId():
  """SoAppearanceKit_getClassTypeId() -> SoType"""
  return _coin.SoAppearanceKit_getClassTypeId()

def SoAppearanceKit_getClassNodekitCatalog():
  """SoAppearanceKit_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoAppearanceKit_getClassNodekitCatalog()

def SoAppearanceKit_initClass():
  """SoAppearanceKit_initClass()"""
  return _coin.SoAppearanceKit_initClass()

class SoCameraKit(SoBaseKit):
    """Proxy of C++ SoCameraKit class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoCameraKit_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoCameraKit_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoCameraKit_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoCameraKit_getNodekitCatalog(self)

    def __init__(self): 
        """__init__(self) -> SoCameraKit"""
        this = _coin.new_SoCameraKit()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoCameraKit_initClass()

    initClass = staticmethod(initClass)
SoCameraKit_swigregister = _coin.SoCameraKit_swigregister
SoCameraKit_swigregister(SoCameraKit)

def SoCameraKit_getClassTypeId():
  """SoCameraKit_getClassTypeId() -> SoType"""
  return _coin.SoCameraKit_getClassTypeId()

def SoCameraKit_getClassNodekitCatalog():
  """SoCameraKit_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoCameraKit_getClassNodekitCatalog()

def SoCameraKit_initClass():
  """SoCameraKit_initClass()"""
  return _coin.SoCameraKit_initClass()

class SoLightKit(SoBaseKit):
    """Proxy of C++ SoLightKit class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoLightKit_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoLightKit_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoLightKit_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoLightKit_getNodekitCatalog(self)

    def __init__(self): 
        """__init__(self) -> SoLightKit"""
        this = _coin.new_SoLightKit()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoLightKit_initClass()

    initClass = staticmethod(initClass)
SoLightKit_swigregister = _coin.SoLightKit_swigregister
SoLightKit_swigregister(SoLightKit)

def SoLightKit_getClassTypeId():
  """SoLightKit_getClassTypeId() -> SoType"""
  return _coin.SoLightKit_getClassTypeId()

def SoLightKit_getClassNodekitCatalog():
  """SoLightKit_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoLightKit_getClassNodekitCatalog()

def SoLightKit_initClass():
  """SoLightKit_initClass()"""
  return _coin.SoLightKit_initClass()

class SoNodeKit(object):
    """Proxy of C++ SoNodeKit class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def init():
        """init()"""
        return _coin.SoNodeKit_init()

    init = staticmethod(init)
    def __init__(self): 
        """__init__(self) -> SoNodeKit"""
        this = _coin.new_SoNodeKit()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoNodeKit
    __del__ = lambda self : None;
SoNodeKit_swigregister = _coin.SoNodeKit_swigregister
SoNodeKit_swigregister(SoNodeKit)

def SoNodeKit_init():
  """SoNodeKit_init()"""
  return _coin.SoNodeKit_init()

class SoSceneKit(SoBaseKit):
    """Proxy of C++ SoSceneKit class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSceneKit_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSceneKit_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoSceneKit_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoSceneKit_getNodekitCatalog(self)

    def initClass():
        """initClass()"""
        return _coin.SoSceneKit_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoSceneKit"""
        this = _coin.new_SoSceneKit()
        try: self.this.append(this)
        except: self.this = this
    def getCameraNumber(self):
        """getCameraNumber(self) -> int"""
        return _coin.SoSceneKit_getCameraNumber(self)

    def setCameraNumber(self, *args):
        """setCameraNumber(self, int camNum)"""
        return _coin.SoSceneKit_setCameraNumber(self, *args)

    def affectsState(self):
        """affectsState(self) -> SbBool"""
        return _coin.SoSceneKit_affectsState(self)

SoSceneKit_swigregister = _coin.SoSceneKit_swigregister
SoSceneKit_swigregister(SoSceneKit)

def SoSceneKit_getClassTypeId():
  """SoSceneKit_getClassTypeId() -> SoType"""
  return _coin.SoSceneKit_getClassTypeId()

def SoSceneKit_getClassNodekitCatalog():
  """SoSceneKit_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoSceneKit_getClassNodekitCatalog()

def SoSceneKit_initClass():
  """SoSceneKit_initClass()"""
  return _coin.SoSceneKit_initClass()

class SoSeparatorKit(SoBaseKit):
    """Proxy of C++ SoSeparatorKit class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSeparatorKit_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSeparatorKit_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoSeparatorKit_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoSeparatorKit_getNodekitCatalog(self)

    def __init__(self): 
        """__init__(self) -> SoSeparatorKit"""
        this = _coin.new_SoSeparatorKit()
        try: self.this.append(this)
        except: self.this = this
    OFF = _coin.SoSeparatorKit_OFF
    ON = _coin.SoSeparatorKit_ON
    AUTO = _coin.SoSeparatorKit_AUTO
    renderCaching = _swig_property(_coin.SoSeparatorKit_renderCaching_get, _coin.SoSeparatorKit_renderCaching_set)
    boundingBoxCaching = _swig_property(_coin.SoSeparatorKit_boundingBoxCaching_get, _coin.SoSeparatorKit_boundingBoxCaching_set)
    renderCulling = _swig_property(_coin.SoSeparatorKit_renderCulling_get, _coin.SoSeparatorKit_renderCulling_set)
    pickCulling = _swig_property(_coin.SoSeparatorKit_pickCulling_get, _coin.SoSeparatorKit_pickCulling_set)
    def initClass():
        """initClass()"""
        return _coin.SoSeparatorKit_initClass()

    initClass = staticmethod(initClass)
SoSeparatorKit_swigregister = _coin.SoSeparatorKit_swigregister
SoSeparatorKit_swigregister(SoSeparatorKit)

def SoSeparatorKit_getClassTypeId():
  """SoSeparatorKit_getClassTypeId() -> SoType"""
  return _coin.SoSeparatorKit_getClassTypeId()

def SoSeparatorKit_getClassNodekitCatalog():
  """SoSeparatorKit_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoSeparatorKit_getClassNodekitCatalog()

def SoSeparatorKit_initClass():
  """SoSeparatorKit_initClass()"""
  return _coin.SoSeparatorKit_initClass()

class SoShapeKit(SoSeparatorKit):
    """Proxy of C++ SoShapeKit class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShapeKit_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoShapeKit_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoShapeKit_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoShapeKit_getNodekitCatalog(self)

    def __init__(self): 
        """__init__(self) -> SoShapeKit"""
        this = _coin.new_SoShapeKit()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoShapeKit_initClass()

    initClass = staticmethod(initClass)
SoShapeKit_swigregister = _coin.SoShapeKit_swigregister
SoShapeKit_swigregister(SoShapeKit)

def SoShapeKit_getClassTypeId():
  """SoShapeKit_getClassTypeId() -> SoType"""
  return _coin.SoShapeKit_getClassTypeId()

def SoShapeKit_getClassNodekitCatalog():
  """SoShapeKit_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoShapeKit_getClassNodekitCatalog()

def SoShapeKit_initClass():
  """SoShapeKit_initClass()"""
  return _coin.SoShapeKit_initClass()

class SoWrapperKit(SoSeparatorKit):
    """Proxy of C++ SoWrapperKit class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoWrapperKit_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoWrapperKit_getTypeId(self)

    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoWrapperKit_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
    def getNodekitCatalog(self):
        """getNodekitCatalog(self) -> SoNodekitCatalog"""
        return _coin.SoWrapperKit_getNodekitCatalog(self)

    def __init__(self): 
        """__init__(self) -> SoWrapperKit"""
        this = _coin.new_SoWrapperKit()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoWrapperKit_initClass()

    initClass = staticmethod(initClass)
SoWrapperKit_swigregister = _coin.SoWrapperKit_swigregister
SoWrapperKit_swigregister(SoWrapperKit)

def SoWrapperKit_getClassTypeId():
  """SoWrapperKit_getClassTypeId() -> SoType"""
  return _coin.SoWrapperKit_getClassTypeId()

def SoWrapperKit_getClassNodekitCatalog():
  """SoWrapperKit_getClassNodekitCatalog() -> SoNodekitCatalog"""
  return _coin.SoWrapperKit_getClassNodekitCatalog()

def SoWrapperKit_initClass():
  """SoWrapperKit_initClass()"""
  return _coin.SoWrapperKit_initClass()

class SoGroup(SoNode):
    """Proxy of C++ SoGroup class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoGroup_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoGroup_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoGroup_initClass()

    initClass = staticmethod(initClass)
    def __init__(self, *args): 
        """
        __init__(self) -> SoGroup
        __init__(self, int nchildren) -> SoGroup
        """
        this = _coin.new_SoGroup(*args)
        try: self.this.append(this)
        except: self.this = this
    def addChild(self, *args):
        """addChild(self, SoNode node)"""
        return _coin.SoGroup_addChild(self, *args)

    def insertChild(self, *args):
        """insertChild(self, SoNode child, int newchildindex)"""
        return _coin.SoGroup_insertChild(self, *args)

    def getChild(self, *args):
        """getChild(self, int index) -> SoNode"""
        return _coin.SoGroup_getChild(self, *args)

    def findChild(self, *args):
        """findChild(self, SoNode node) -> int"""
        return _coin.SoGroup_findChild(self, *args)

    def getNumChildren(self):
        """getNumChildren(self) -> int"""
        return _coin.SoGroup_getNumChildren(self)

    def removeChild(self, *args):
        """
        removeChild(self, int childindex)
        removeChild(self, SoNode child)
        """
        return _coin.SoGroup_removeChild(self, *args)

    def removeAllChildren(self):
        """removeAllChildren(self)"""
        return _coin.SoGroup_removeAllChildren(self)

    def replaceChild(self, *args):
        """
        replaceChild(self, int index, SoNode newchild)
        replaceChild(self, SoNode oldchild, SoNode newchild)
        """
        return _coin.SoGroup_replaceChild(self, *args)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoGroup_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoGroup_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoGroup_callback(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoGroup_getBoundingBox(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoGroup_getMatrix(self, *args)

    def handleEvent(self, *args):
        """handleEvent(self, SoHandleEventAction action)"""
        return _coin.SoGroup_handleEvent(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoGroup_pick(self, *args)

    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoGroup_search(self, *args)

    def write(self, *args):
        """write(self, SoWriteAction action)"""
        return _coin.SoGroup_write(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoGroup_getPrimitiveCount(self, *args)

    def audioRender(self, *args):
        """audioRender(self, SoAudioRenderAction action)"""
        return _coin.SoGroup_audioRender(self, *args)

    def getChildren(self):
        """getChildren(self) -> SoChildList"""
        return _coin.SoGroup_getChildren(self)

    def __iter__(self):
       i = 0
       while i < self.getNumChildren():
          yield self.getChild(i)
          i += 1

    def __len__(self, *args):
        """__len__(self) -> int"""
        return _coin.SoGroup___len__(self, *args)

    def __contains__(self, *args):
        """__contains__(self, SoNode node) -> int"""
        return _coin.SoGroup___contains__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int index) -> SoNode"""
        return _coin.SoGroup___getitem__(self, *args)

SoGroup_swigregister = _coin.SoGroup_swigregister
SoGroup_swigregister(SoGroup)

def SoGroup_getClassTypeId():
  """SoGroup_getClassTypeId() -> SoType"""
  return _coin.SoGroup_getClassTypeId()

def SoGroup_initClass():
  """SoGroup_initClass()"""
  return _coin.SoGroup_initClass()

class SoSeparator(SoGroup):
    """Proxy of C++ SoSeparator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSeparator_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSeparator_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoSeparator_initClass()

    initClass = staticmethod(initClass)
    def __init__(self, *args): 
        """
        __init__(self) -> SoSeparator
        __init__(self, int nchildren) -> SoSeparator
        """
        this = _coin.new_SoSeparator(*args)
        try: self.this.append(this)
        except: self.this = this
    OFF = _coin.SoSeparator_OFF
    ON = _coin.SoSeparator_ON
    AUTO = _coin.SoSeparator_AUTO
    renderCaching = _swig_property(_coin.SoSeparator_renderCaching_get, _coin.SoSeparator_renderCaching_set)
    boundingBoxCaching = _swig_property(_coin.SoSeparator_boundingBoxCaching_get, _coin.SoSeparator_boundingBoxCaching_set)
    renderCulling = _swig_property(_coin.SoSeparator_renderCulling_get, _coin.SoSeparator_renderCulling_set)
    pickCulling = _swig_property(_coin.SoSeparator_pickCulling_get, _coin.SoSeparator_pickCulling_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoSeparator_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoSeparator_GLRender(self, *args)

    def GLRenderBelowPath(self, *args):
        """GLRenderBelowPath(self, SoGLRenderAction action)"""
        return _coin.SoSeparator_GLRenderBelowPath(self, *args)

    def GLRenderInPath(self, *args):
        """GLRenderInPath(self, SoGLRenderAction action)"""
        return _coin.SoSeparator_GLRenderInPath(self, *args)

    def GLRenderOffPath(self, *args):
        """GLRenderOffPath(self, SoGLRenderAction action)"""
        return _coin.SoSeparator_GLRenderOffPath(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoSeparator_callback(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoSeparator_getBoundingBox(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoSeparator_getMatrix(self, *args)

    def handleEvent(self, *args):
        """handleEvent(self, SoHandleEventAction action)"""
        return _coin.SoSeparator_handleEvent(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoSeparator_rayPick(self, *args)

    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoSeparator_search(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoSeparator_getPrimitiveCount(self, *args)

    def audioRender(self, *args):
        """audioRender(self, SoAudioRenderAction action)"""
        return _coin.SoSeparator_audioRender(self, *args)

    def notify(self, *args):
        """notify(self, SoNotList nl)"""
        return _coin.SoSeparator_notify(self, *args)

    def setNumRenderCaches(*args):
        """setNumRenderCaches(int howmany)"""
        return _coin.SoSeparator_setNumRenderCaches(*args)

    setNumRenderCaches = staticmethod(setNumRenderCaches)
    def getNumRenderCaches():
        """getNumRenderCaches() -> int"""
        return _coin.SoSeparator_getNumRenderCaches()

    getNumRenderCaches = staticmethod(getNumRenderCaches)
    def affectsState(self):
        """affectsState(self) -> SbBool"""
        return _coin.SoSeparator_affectsState(self)

SoSeparator_swigregister = _coin.SoSeparator_swigregister
SoSeparator_swigregister(SoSeparator)

def SoSeparator_getClassTypeId():
  """SoSeparator_getClassTypeId() -> SoType"""
  return _coin.SoSeparator_getClassTypeId()

def SoSeparator_initClass():
  """SoSeparator_initClass()"""
  return _coin.SoSeparator_initClass()

def SoSeparator_setNumRenderCaches(*args):
  """SoSeparator_setNumRenderCaches(int howmany)"""
  return _coin.SoSeparator_setNumRenderCaches(*args)

def SoSeparator_getNumRenderCaches():
  """SoSeparator_getNumRenderCaches() -> int"""
  return _coin.SoSeparator_getNumRenderCaches()

class SoAnnotation(SoSeparator):
    """Proxy of C++ SoAnnotation class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoAnnotation_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoAnnotation_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoAnnotation_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoAnnotation"""
        this = _coin.new_SoAnnotation()
        try: self.this.append(this)
        except: self.this = this
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoAnnotation_GLRender(self, *args)

    def GLRenderBelowPath(self, *args):
        """GLRenderBelowPath(self, SoGLRenderAction action)"""
        return _coin.SoAnnotation_GLRenderBelowPath(self, *args)

    def GLRenderInPath(self, *args):
        """GLRenderInPath(self, SoGLRenderAction action)"""
        return _coin.SoAnnotation_GLRenderInPath(self, *args)

    def GLRenderOffPath(self, *args):
        """GLRenderOffPath(self, SoGLRenderAction action)"""
        return _coin.SoAnnotation_GLRenderOffPath(self, *args)

SoAnnotation_swigregister = _coin.SoAnnotation_swigregister
SoAnnotation_swigregister(SoAnnotation)

def SoAnnotation_getClassTypeId():
  """SoAnnotation_getClassTypeId() -> SoType"""
  return _coin.SoAnnotation_getClassTypeId()

def SoAnnotation_initClass():
  """SoAnnotation_initClass()"""
  return _coin.SoAnnotation_initClass()

class SoAntiSquish(SoTransformation):
    """Proxy of C++ SoAntiSquish class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoAntiSquish_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoAntiSquish_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoAntiSquish_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoAntiSquish"""
        this = _coin.new_SoAntiSquish()
        try: self.this.append(this)
        except: self.this = this
    X = _coin.SoAntiSquish_X
    Y = _coin.SoAntiSquish_Y
    Z = _coin.SoAntiSquish_Z
    AVERAGE_DIMENSION = _coin.SoAntiSquish_AVERAGE_DIMENSION
    BIGGEST_DIMENSION = _coin.SoAntiSquish_BIGGEST_DIMENSION
    SMALLEST_DIMENSION = _coin.SoAntiSquish_SMALLEST_DIMENSION
    LONGEST_DIAGONAL = _coin.SoAntiSquish_LONGEST_DIAGONAL
    sizing = _swig_property(_coin.SoAntiSquish_sizing_get, _coin.SoAntiSquish_sizing_set)
    recalcAlways = _swig_property(_coin.SoAntiSquish_recalcAlways_get, _coin.SoAntiSquish_recalcAlways_set)
    def recalc(self):
        """recalc(self)"""
        return _coin.SoAntiSquish_recalc(self)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoAntiSquish_doAction(self, *args)

SoAntiSquish_swigregister = _coin.SoAntiSquish_swigregister
SoAntiSquish_swigregister(SoAntiSquish)

def SoAntiSquish_getClassTypeId():
  """SoAntiSquish_getClassTypeId() -> SoType"""
  return _coin.SoAntiSquish_getClassTypeId()

def SoAntiSquish_initClass():
  """SoAntiSquish_initClass()"""
  return _coin.SoAntiSquish_initClass()

class SoArray(SoGroup):
    """Proxy of C++ SoArray class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoArray_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoArray_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoArray_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoArray"""
        this = _coin.new_SoArray()
        try: self.this.append(this)
        except: self.this = this
    FIRST = _coin.SoArray_FIRST
    CENTER = _coin.SoArray_CENTER
    LAST = _coin.SoArray_LAST
    origin = _swig_property(_coin.SoArray_origin_get, _coin.SoArray_origin_set)
    numElements1 = _swig_property(_coin.SoArray_numElements1_get, _coin.SoArray_numElements1_set)
    numElements2 = _swig_property(_coin.SoArray_numElements2_get, _coin.SoArray_numElements2_set)
    numElements3 = _swig_property(_coin.SoArray_numElements3_get, _coin.SoArray_numElements3_set)
    separation1 = _swig_property(_coin.SoArray_separation1_get, _coin.SoArray_separation1_set)
    separation2 = _swig_property(_coin.SoArray_separation2_get, _coin.SoArray_separation2_set)
    separation3 = _swig_property(_coin.SoArray_separation3_get, _coin.SoArray_separation3_set)
    def affectsState(self):
        """affectsState(self) -> SbBool"""
        return _coin.SoArray_affectsState(self)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoArray_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoArray_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoArray_GLRender(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoArray_pick(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoArray_getBoundingBox(self, *args)

    def handleEvent(self, *args):
        """handleEvent(self, SoHandleEventAction action)"""
        return _coin.SoArray_handleEvent(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoArray_getMatrix(self, *args)

    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoArray_search(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoArray_getPrimitiveCount(self, *args)

    def audioRender(self, *args):
        """audioRender(self, SoAudioRenderAction action)"""
        return _coin.SoArray_audioRender(self, *args)

SoArray_swigregister = _coin.SoArray_swigregister
SoArray_swigregister(SoArray)

def SoArray_getClassTypeId():
  """SoArray_getClassTypeId() -> SoType"""
  return _coin.SoArray_getClassTypeId()

def SoArray_initClass():
  """SoArray_initClass()"""
  return _coin.SoArray_initClass()

class SoAsciiText(SoShape):
    """Proxy of C++ SoAsciiText class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoAsciiText_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoAsciiText_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoAsciiText_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoAsciiText"""
        this = _coin.new_SoAsciiText()
        try: self.this.append(this)
        except: self.this = this
    LEFT = _coin.SoAsciiText_LEFT
    RIGHT = _coin.SoAsciiText_RIGHT
    CENTER = _coin.SoAsciiText_CENTER
    string = _swig_property(_coin.SoAsciiText_string_get, _coin.SoAsciiText_string_set)
    spacing = _swig_property(_coin.SoAsciiText_spacing_get, _coin.SoAsciiText_spacing_set)
    justification = _swig_property(_coin.SoAsciiText_justification_get, _coin.SoAsciiText_justification_set)
    width = _swig_property(_coin.SoAsciiText_width_get, _coin.SoAsciiText_width_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoAsciiText_GLRender(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoAsciiText_getPrimitiveCount(self, *args)

SoAsciiText_swigregister = _coin.SoAsciiText_swigregister
SoAsciiText_swigregister(SoAsciiText)

def SoAsciiText_getClassTypeId():
  """SoAsciiText_getClassTypeId() -> SoType"""
  return _coin.SoAsciiText_getClassTypeId()

def SoAsciiText_initClass():
  """SoAsciiText_initClass()"""
  return _coin.SoAsciiText_initClass()

class SoBaseColor(SoNode):
    """Proxy of C++ SoBaseColor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoBaseColor_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoBaseColor_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoBaseColor_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoBaseColor"""
        this = _coin.new_SoBaseColor()
        try: self.this.append(this)
        except: self.this = this
    rgb = _swig_property(_coin.SoBaseColor_rgb_get, _coin.SoBaseColor_rgb_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoBaseColor_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoBaseColor_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoBaseColor_callback(self, *args)

SoBaseColor_swigregister = _coin.SoBaseColor_swigregister
SoBaseColor_swigregister(SoBaseColor)

def SoBaseColor_getClassTypeId():
  """SoBaseColor_getClassTypeId() -> SoType"""
  return _coin.SoBaseColor_getClassTypeId()

def SoBaseColor_initClass():
  """SoBaseColor_initClass()"""
  return _coin.SoBaseColor_initClass()

SO_SWITCH_NONE = _coin.SO_SWITCH_NONE
SO_SWITCH_INHERIT = _coin.SO_SWITCH_INHERIT
SO_SWITCH_ALL = _coin.SO_SWITCH_ALL
class SoSwitch(SoGroup):
    """Proxy of C++ SoSwitch class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSwitch_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSwitch_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoSwitch_initClass()

    initClass = staticmethod(initClass)
    def __init__(self, *args): 
        """
        __init__(self) -> SoSwitch
        __init__(self, int numchildren) -> SoSwitch
        """
        this = _coin.new_SoSwitch(*args)
        try: self.this.append(this)
        except: self.this = this
    whichChild = _swig_property(_coin.SoSwitch_whichChild_get, _coin.SoSwitch_whichChild_set)
    def affectsState(self):
        """affectsState(self) -> SbBool"""
        return _coin.SoSwitch_affectsState(self)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoSwitch_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoSwitch_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoSwitch_GLRender(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoSwitch_pick(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoSwitch_getBoundingBox(self, *args)

    def handleEvent(self, *args):
        """handleEvent(self, SoHandleEventAction action)"""
        return _coin.SoSwitch_handleEvent(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoSwitch_getMatrix(self, *args)

    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoSwitch_search(self, *args)

    def write(self, *args):
        """write(self, SoWriteAction action)"""
        return _coin.SoSwitch_write(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoSwitch_getPrimitiveCount(self, *args)

    def audioRender(self, *args):
        """audioRender(self, SoAudioRenderAction action)"""
        return _coin.SoSwitch_audioRender(self, *args)

    def notify(self, *args):
        """notify(self, SoNotList nl)"""
        return _coin.SoSwitch_notify(self, *args)

SoSwitch_swigregister = _coin.SoSwitch_swigregister
SoSwitch_swigregister(SoSwitch)

def SoSwitch_getClassTypeId():
  """SoSwitch_getClassTypeId() -> SoType"""
  return _coin.SoSwitch_getClassTypeId()

def SoSwitch_initClass():
  """SoSwitch_initClass()"""
  return _coin.SoSwitch_initClass()

class SoBlinker(SoSwitch):
    """Proxy of C++ SoBlinker class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoBlinker_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoBlinker_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoBlinker_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoBlinker"""
        this = _coin.new_SoBlinker()
        try: self.this.append(this)
        except: self.this = this
    speed = _swig_property(_coin.SoBlinker_speed_get, _coin.SoBlinker_speed_set)
    on = _swig_property(_coin.SoBlinker_on_get, _coin.SoBlinker_on_set)
    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoBlinker_getBoundingBox(self, *args)

    def write(self, *args):
        """write(self, SoWriteAction action)"""
        return _coin.SoBlinker_write(self, *args)

SoBlinker_swigregister = _coin.SoBlinker_swigregister
SoBlinker_swigregister(SoBlinker)

def SoBlinker_getClassTypeId():
  """SoBlinker_getClassTypeId() -> SoType"""
  return _coin.SoBlinker_getClassTypeId()

def SoBlinker_initClass():
  """SoBlinker_initClass()"""
  return _coin.SoBlinker_initClass()

class SoBumpMapCoordinate(SoNode):
    """Proxy of C++ SoBumpMapCoordinate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoBumpMapCoordinate_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoBumpMapCoordinate_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoBumpMapCoordinate_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoBumpMapCoordinate"""
        this = _coin.new_SoBumpMapCoordinate()
        try: self.this.append(this)
        except: self.this = this
    point = _swig_property(_coin.SoBumpMapCoordinate_point_get, _coin.SoBumpMapCoordinate_point_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoBumpMapCoordinate_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoBumpMapCoordinate_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoBumpMapCoordinate_callback(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoBumpMapCoordinate_pick(self, *args)

SoBumpMapCoordinate_swigregister = _coin.SoBumpMapCoordinate_swigregister
SoBumpMapCoordinate_swigregister(SoBumpMapCoordinate)

def SoBumpMapCoordinate_getClassTypeId():
  """SoBumpMapCoordinate_getClassTypeId() -> SoType"""
  return _coin.SoBumpMapCoordinate_getClassTypeId()

def SoBumpMapCoordinate_initClass():
  """SoBumpMapCoordinate_initClass()"""
  return _coin.SoBumpMapCoordinate_initClass()

class SoBumpMap(SoNode):
    """Proxy of C++ SoBumpMap class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoBumpMap_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoBumpMap_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoBumpMap_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoBumpMap"""
        this = _coin.new_SoBumpMap()
        try: self.this.append(this)
        except: self.this = this
    REPEAT = _coin.SoBumpMap_REPEAT
    CLAMP = _coin.SoBumpMap_CLAMP
    filename = _swig_property(_coin.SoBumpMap_filename_get, _coin.SoBumpMap_filename_set)
    image = _swig_property(_coin.SoBumpMap_image_get, _coin.SoBumpMap_image_set)
    wrapS = _swig_property(_coin.SoBumpMap_wrapS_get, _coin.SoBumpMap_wrapS_set)
    wrapT = _swig_property(_coin.SoBumpMap_wrapT_get, _coin.SoBumpMap_wrapT_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoBumpMap_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoBumpMap_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoBumpMap_callback(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoBumpMap_rayPick(self, *args)

SoBumpMap_swigregister = _coin.SoBumpMap_swigregister
SoBumpMap_swigregister(SoBumpMap)

def SoBumpMap_getClassTypeId():
  """SoBumpMap_getClassTypeId() -> SoType"""
  return _coin.SoBumpMap_getClassTypeId()

def SoBumpMap_initClass():
  """SoBumpMap_initClass()"""
  return _coin.SoBumpMap_initClass()

class SoBumpMapTransform(SoNode):
    """Proxy of C++ SoBumpMapTransform class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoBumpMapTransform_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoBumpMapTransform_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoBumpMapTransform_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoBumpMapTransform"""
        this = _coin.new_SoBumpMapTransform()
        try: self.this.append(this)
        except: self.this = this
    translation = _swig_property(_coin.SoBumpMapTransform_translation_get, _coin.SoBumpMapTransform_translation_set)
    rotation = _swig_property(_coin.SoBumpMapTransform_rotation_get, _coin.SoBumpMapTransform_rotation_set)
    scaleFactor = _swig_property(_coin.SoBumpMapTransform_scaleFactor_get, _coin.SoBumpMapTransform_scaleFactor_set)
    center = _swig_property(_coin.SoBumpMapTransform_center_get, _coin.SoBumpMapTransform_center_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoBumpMapTransform_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoBumpMapTransform_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoBumpMapTransform_GLRender(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoBumpMapTransform_getMatrix(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoBumpMapTransform_pick(self, *args)

SoBumpMapTransform_swigregister = _coin.SoBumpMapTransform_swigregister
SoBumpMapTransform_swigregister(SoBumpMapTransform)

def SoBumpMapTransform_getClassTypeId():
  """SoBumpMapTransform_getClassTypeId() -> SoType"""
  return _coin.SoBumpMapTransform_getClassTypeId()

def SoBumpMapTransform_initClass():
  """SoBumpMapTransform_initClass()"""
  return _coin.SoBumpMapTransform_initClass()

class SoCallback(SoNode):
    """Proxy of C++ SoCallback class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoCallback_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoCallback_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoCallback_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoCallback"""
        this = _coin.new_SoCallback()
        try: self.this.append(this)
        except: self.this = this
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoCallback_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoCallback_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoCallback_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoCallback_getBoundingBox(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoCallback_getMatrix(self, *args)

    def handleEvent(self, *args):
        """handleEvent(self, SoHandleEventAction action)"""
        return _coin.SoCallback_handleEvent(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoCallback_pick(self, *args)

    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoCallback_search(self, *args)

    def write(self, *args):
        """write(self, SoWriteAction action)"""
        return _coin.SoCallback_write(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoCallback_getPrimitiveCount(self, *args)

    def setCallback(self, *args):
        """
        setCallback(self, SoCallbackCB function, void userdata = None)
        setCallback(self, SoCallbackCB function)
        setCallback(self, PyObject pyfunc, PyObject userdata = None)
        setCallback(self, PyObject pyfunc)
        """
        return _coin.SoCallback_setCallback(self, *args)

SoCallback_swigregister = _coin.SoCallback_swigregister
SoCallback_swigregister(SoCallback)

def SoCallback_getClassTypeId():
  """SoCallback_getClassTypeId() -> SoType"""
  return _coin.SoCallback_getClassTypeId()

def SoCallback_initClass():
  """SoCallback_initClass()"""
  return _coin.SoCallback_initClass()

SO_ASPECT_SQUARE = _coin.SO_ASPECT_SQUARE
SO_ASPECT_VIDEO = _coin.SO_ASPECT_VIDEO
SO_ASPECT_35mm_ACADEMY = _coin.SO_ASPECT_35mm_ACADEMY
SO_ASPECT_16mm = _coin.SO_ASPECT_16mm
SO_ASPECT_35mm_FULL = _coin.SO_ASPECT_35mm_FULL
SO_ASPECT_70mm = _coin.SO_ASPECT_70mm
SO_ASPECT_CINEMASCOPE = _coin.SO_ASPECT_CINEMASCOPE
SO_ASPECT_HDTV = _coin.SO_ASPECT_HDTV
SO_ASPECT_PANAVISION = _coin.SO_ASPECT_PANAVISION
SO_ASPECT_35mm = _coin.SO_ASPECT_35mm
SO_ASPECT_VISTAVISION = _coin.SO_ASPECT_VISTAVISION
class SoCamera(SoNode):
    """Proxy of C++ SoCamera class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoCamera_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoCamera_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoCamera_initClass()

    initClass = staticmethod(initClass)
    CROP_VIEWPORT_FILL_FRAME = _coin.SoCamera_CROP_VIEWPORT_FILL_FRAME
    CROP_VIEWPORT_LINE_FRAME = _coin.SoCamera_CROP_VIEWPORT_LINE_FRAME
    CROP_VIEWPORT_NO_FRAME = _coin.SoCamera_CROP_VIEWPORT_NO_FRAME
    ADJUST_CAMERA = _coin.SoCamera_ADJUST_CAMERA
    LEAVE_ALONE = _coin.SoCamera_LEAVE_ALONE
    viewportMapping = _swig_property(_coin.SoCamera_viewportMapping_get, _coin.SoCamera_viewportMapping_set)
    position = _swig_property(_coin.SoCamera_position_get, _coin.SoCamera_position_set)
    orientation = _swig_property(_coin.SoCamera_orientation_get, _coin.SoCamera_orientation_set)
    aspectRatio = _swig_property(_coin.SoCamera_aspectRatio_get, _coin.SoCamera_aspectRatio_set)
    nearDistance = _swig_property(_coin.SoCamera_nearDistance_get, _coin.SoCamera_nearDistance_set)
    farDistance = _swig_property(_coin.SoCamera_farDistance_get, _coin.SoCamera_farDistance_set)
    focalDistance = _swig_property(_coin.SoCamera_focalDistance_get, _coin.SoCamera_focalDistance_set)
    def pointAt(self, *args):
        """
        pointAt(self, SbVec3f targetpoint)
        pointAt(self, SbVec3f targetpoint, SbVec3f upvector)
        """
        return _coin.SoCamera_pointAt(self, *args)

    def scaleHeight(self, *args):
        """scaleHeight(self, float scalefactor)"""
        return _coin.SoCamera_scaleHeight(self, *args)

    def getViewVolume(self, useaspectratio = 0.0):
        """
        getViewVolume(self, float useaspectratio = 0.0) -> SbViewVolume
        getViewVolume(self) -> SbViewVolume
        """
        return _coin.SoCamera_getViewVolume(self, useaspectratio)

    def viewAll(self, *args):
        """
        viewAll(self, SoNode sceneroot, SbViewportRegion vpregion, float slack = 1.0)
        viewAll(self, SoNode sceneroot, SbViewportRegion vpregion)
        viewAll(self, SoPath path, SbViewportRegion vpregion, float slack = 1.0)
        viewAll(self, SoPath path, SbViewportRegion vpregion)
        """
        return _coin.SoCamera_viewAll(self, *args)

    def getViewportBounds(self, *args):
        """getViewportBounds(self, SbViewportRegion region) -> SbViewportRegion"""
        return _coin.SoCamera_getViewportBounds(self, *args)

    MONOSCOPIC = _coin.SoCamera_MONOSCOPIC
    LEFT_VIEW = _coin.SoCamera_LEFT_VIEW
    RIGHT_VIEW = _coin.SoCamera_RIGHT_VIEW
    def setStereoMode(self, *args):
        """setStereoMode(self, StereoMode mode)"""
        return _coin.SoCamera_setStereoMode(self, *args)

    def getStereoMode(self):
        """getStereoMode(self) -> StereoMode"""
        return _coin.SoCamera_getStereoMode(self)

    def setStereoAdjustment(self, *args):
        """setStereoAdjustment(self, float adjustment)"""
        return _coin.SoCamera_setStereoAdjustment(self, *args)

    def getStereoAdjustment(self):
        """getStereoAdjustment(self) -> float"""
        return _coin.SoCamera_getStereoAdjustment(self)

    def setBalanceAdjustment(self, *args):
        """setBalanceAdjustment(self, float adjustment)"""
        return _coin.SoCamera_setBalanceAdjustment(self, *args)

    def getBalanceAdjustment(self):
        """getBalanceAdjustment(self) -> float"""
        return _coin.SoCamera_getBalanceAdjustment(self)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoCamera_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoCamera_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoCamera_GLRender(self, *args)

    def audioRender(self, *args):
        """audioRender(self, SoAudioRenderAction action)"""
        return _coin.SoCamera_audioRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoCamera_getBoundingBox(self, *args)

    def handleEvent(self, *args):
        """handleEvent(self, SoHandleEventAction action)"""
        return _coin.SoCamera_handleEvent(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoCamera_rayPick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoCamera_getPrimitiveCount(self, *args)

SoCamera_swigregister = _coin.SoCamera_swigregister
SoCamera_swigregister(SoCamera)

def SoCamera_getClassTypeId():
  """SoCamera_getClassTypeId() -> SoType"""
  return _coin.SoCamera_getClassTypeId()

def SoCamera_initClass():
  """SoCamera_initClass()"""
  return _coin.SoCamera_initClass()

class SoColorIndex(SoNode):
    """Proxy of C++ SoColorIndex class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoColorIndex_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoColorIndex_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoColorIndex_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoColorIndex"""
        this = _coin.new_SoColorIndex()
        try: self.this.append(this)
        except: self.this = this
    index = _swig_property(_coin.SoColorIndex_index_get, _coin.SoColorIndex_index_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoColorIndex_GLRender(self, *args)

SoColorIndex_swigregister = _coin.SoColorIndex_swigregister
SoColorIndex_swigregister(SoColorIndex)

def SoColorIndex_getClassTypeId():
  """SoColorIndex_getClassTypeId() -> SoType"""
  return _coin.SoColorIndex_getClassTypeId()

def SoColorIndex_initClass():
  """SoColorIndex_initClass()"""
  return _coin.SoColorIndex_initClass()

class SoCone(SoShape):
    """Proxy of C++ SoCone class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoCone_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoCone_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoCone_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoCone"""
        this = _coin.new_SoCone()
        try: self.this.append(this)
        except: self.this = this
    SIDES = _coin.SoCone_SIDES
    BOTTOM = _coin.SoCone_BOTTOM
    ALL = _coin.SoCone_ALL
    parts = _swig_property(_coin.SoCone_parts_get, _coin.SoCone_parts_set)
    bottomRadius = _swig_property(_coin.SoCone_bottomRadius_get, _coin.SoCone_bottomRadius_set)
    height = _swig_property(_coin.SoCone_height_get, _coin.SoCone_height_set)
    def addPart(self, *args):
        """addPart(self, Part part)"""
        return _coin.SoCone_addPart(self, *args)

    def removePart(self, *args):
        """removePart(self, Part part)"""
        return _coin.SoCone_removePart(self, *args)

    def hasPart(self, *args):
        """hasPart(self, Part part) -> SbBool"""
        return _coin.SoCone_hasPart(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoCone_GLRender(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoCone_rayPick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoCone_getPrimitiveCount(self, *args)

SoCone_swigregister = _coin.SoCone_swigregister
SoCone_swigregister(SoCone)

def SoCone_getClassTypeId():
  """SoCone_getClassTypeId() -> SoType"""
  return _coin.SoCone_getClassTypeId()

def SoCone_initClass():
  """SoCone_initClass()"""
  return _coin.SoCone_initClass()

class SoCoordinate3(SoNode):
    """Proxy of C++ SoCoordinate3 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoCoordinate3_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoCoordinate3_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoCoordinate3_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoCoordinate3"""
        this = _coin.new_SoCoordinate3()
        try: self.this.append(this)
        except: self.this = this
    point = _swig_property(_coin.SoCoordinate3_point_get, _coin.SoCoordinate3_point_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoCoordinate3_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoCoordinate3_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoCoordinate3_callback(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoCoordinate3_getBoundingBox(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoCoordinate3_pick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoCoordinate3_getPrimitiveCount(self, *args)

SoCoordinate3_swigregister = _coin.SoCoordinate3_swigregister
SoCoordinate3_swigregister(SoCoordinate3)

def SoCoordinate3_getClassTypeId():
  """SoCoordinate3_getClassTypeId() -> SoType"""
  return _coin.SoCoordinate3_getClassTypeId()

def SoCoordinate3_initClass():
  """SoCoordinate3_initClass()"""
  return _coin.SoCoordinate3_initClass()

class SoCoordinate4(SoNode):
    """Proxy of C++ SoCoordinate4 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoCoordinate4_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoCoordinate4_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoCoordinate4_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoCoordinate4"""
        this = _coin.new_SoCoordinate4()
        try: self.this.append(this)
        except: self.this = this
    point = _swig_property(_coin.SoCoordinate4_point_get, _coin.SoCoordinate4_point_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoCoordinate4_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoCoordinate4_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoCoordinate4_getBoundingBox(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoCoordinate4_callback(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoCoordinate4_pick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoCoordinate4_getPrimitiveCount(self, *args)

SoCoordinate4_swigregister = _coin.SoCoordinate4_swigregister
SoCoordinate4_swigregister(SoCoordinate4)

def SoCoordinate4_getClassTypeId():
  """SoCoordinate4_getClassTypeId() -> SoType"""
  return _coin.SoCoordinate4_getClassTypeId()

def SoCoordinate4_initClass():
  """SoCoordinate4_initClass()"""
  return _coin.SoCoordinate4_initClass()

class SoCube(SoShape):
    """Proxy of C++ SoCube class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoCube_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoCube_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoCube_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoCube"""
        this = _coin.new_SoCube()
        try: self.this.append(this)
        except: self.this = this
    width = _swig_property(_coin.SoCube_width_get, _coin.SoCube_width_set)
    height = _swig_property(_coin.SoCube_height_get, _coin.SoCube_height_set)
    depth = _swig_property(_coin.SoCube_depth_get, _coin.SoCube_depth_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoCube_GLRender(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoCube_rayPick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoCube_getPrimitiveCount(self, *args)

SoCube_swigregister = _coin.SoCube_swigregister
SoCube_swigregister(SoCube)

def SoCube_getClassTypeId():
  """SoCube_getClassTypeId() -> SoType"""
  return _coin.SoCube_getClassTypeId()

def SoCube_initClass():
  """SoCube_initClass()"""
  return _coin.SoCube_initClass()

class SoCylinder(SoShape):
    """Proxy of C++ SoCylinder class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoCylinder_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoCylinder_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoCylinder_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoCylinder"""
        this = _coin.new_SoCylinder()
        try: self.this.append(this)
        except: self.this = this
    SIDES = _coin.SoCylinder_SIDES
    TOP = _coin.SoCylinder_TOP
    BOTTOM = _coin.SoCylinder_BOTTOM
    ALL = _coin.SoCylinder_ALL
    radius = _swig_property(_coin.SoCylinder_radius_get, _coin.SoCylinder_radius_set)
    height = _swig_property(_coin.SoCylinder_height_get, _coin.SoCylinder_height_set)
    parts = _swig_property(_coin.SoCylinder_parts_get, _coin.SoCylinder_parts_set)
    def addPart(self, *args):
        """addPart(self, Part part)"""
        return _coin.SoCylinder_addPart(self, *args)

    def removePart(self, *args):
        """removePart(self, Part part)"""
        return _coin.SoCylinder_removePart(self, *args)

    def hasPart(self, *args):
        """hasPart(self, Part part) -> SbBool"""
        return _coin.SoCylinder_hasPart(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoCylinder_rayPick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoCylinder_getPrimitiveCount(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoCylinder_GLRender(self, *args)

SoCylinder_swigregister = _coin.SoCylinder_swigregister
SoCylinder_swigregister(SoCylinder)

def SoCylinder_getClassTypeId():
  """SoCylinder_getClassTypeId() -> SoType"""
  return _coin.SoCylinder_getClassTypeId()

def SoCylinder_initClass():
  """SoCylinder_initClass()"""
  return _coin.SoCylinder_initClass()

class SoEnvironment(SoNode):
    """Proxy of C++ SoEnvironment class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoEnvironment_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoEnvironment_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoEnvironment_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoEnvironment"""
        this = _coin.new_SoEnvironment()
        try: self.this.append(this)
        except: self.this = this
    NONE = _coin.SoEnvironment_NONE
    HAZE = _coin.SoEnvironment_HAZE
    FOG = _coin.SoEnvironment_FOG
    SMOKE = _coin.SoEnvironment_SMOKE
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoEnvironment_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoEnvironment_callback(self, *args)

    ambientIntensity = _swig_property(_coin.SoEnvironment_ambientIntensity_get, _coin.SoEnvironment_ambientIntensity_set)
    ambientColor = _swig_property(_coin.SoEnvironment_ambientColor_get, _coin.SoEnvironment_ambientColor_set)
    attenuation = _swig_property(_coin.SoEnvironment_attenuation_get, _coin.SoEnvironment_attenuation_set)
    fogType = _swig_property(_coin.SoEnvironment_fogType_get, _coin.SoEnvironment_fogType_set)
    fogColor = _swig_property(_coin.SoEnvironment_fogColor_get, _coin.SoEnvironment_fogColor_set)
    fogVisibility = _swig_property(_coin.SoEnvironment_fogVisibility_get, _coin.SoEnvironment_fogVisibility_set)
SoEnvironment_swigregister = _coin.SoEnvironment_swigregister
SoEnvironment_swigregister(SoEnvironment)

def SoEnvironment_getClassTypeId():
  """SoEnvironment_getClassTypeId() -> SoType"""
  return _coin.SoEnvironment_getClassTypeId()

def SoEnvironment_initClass():
  """SoEnvironment_initClass()"""
  return _coin.SoEnvironment_initClass()

class SoEventCallback(SoNode):
    """Proxy of C++ SoEventCallback class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoEventCallback_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoEventCallback_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoEventCallback_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoEventCallback"""
        this = _coin.new_SoEventCallback()
        try: self.this.append(this)
        except: self.this = this
    def setPath(self, *args):
        """setPath(self, SoPath path)"""
        return _coin.SoEventCallback_setPath(self, *args)

    def getPath(self):
        """getPath(self) -> SoPath"""
        return _coin.SoEventCallback_getPath(self)

    def getAction(self):
        """getAction(self) -> SoHandleEventAction"""
        return _coin.SoEventCallback_getAction(self)

    def getEvent(self):
        """getEvent(self) -> SoEvent"""
        return _coin.SoEventCallback_getEvent(self)

    def getPickedPoint(self):
        """getPickedPoint(self) -> SoPickedPoint"""
        return _coin.SoEventCallback_getPickedPoint(self)

    def setHandled(self):
        """setHandled(self)"""
        return _coin.SoEventCallback_setHandled(self)

    def isHandled(self):
        """isHandled(self) -> SbBool"""
        return _coin.SoEventCallback_isHandled(self)

    def grabEvents(self):
        """grabEvents(self)"""
        return _coin.SoEventCallback_grabEvents(self)

    def releaseEvents(self):
        """releaseEvents(self)"""
        return _coin.SoEventCallback_releaseEvents(self)

    def addEventCallback(self, *args):
        """
        addEventCallback(self, SoType eventtype, SoEventCallbackCB f, void userdata = None)
        addEventCallback(self, SoType eventtype, SoEventCallbackCB f)
        addEventCallback(self, SoType eventtype, PyObject pyfunc, PyObject userdata = None)
        addEventCallback(self, SoType eventtype, PyObject pyfunc)
        """
        return _coin.SoEventCallback_addEventCallback(self, *args)

    def removeEventCallback(self, *args):
        """
        removeEventCallback(self, SoType eventtype, SoEventCallbackCB f, void userdata = None)
        removeEventCallback(self, SoType eventtype, SoEventCallbackCB f)
        removeEventCallback(self, SoType eventtype, PyObject pyfunc, PyObject userdata = None)
        removeEventCallback(self, SoType eventtype, PyObject pyfunc)
        """
        return _coin.SoEventCallback_removeEventCallback(self, *args)

SoEventCallback_swigregister = _coin.SoEventCallback_swigregister
SoEventCallback_swigregister(SoEventCallback)

def SoEventCallback_getClassTypeId():
  """SoEventCallback_getClassTypeId() -> SoType"""
  return _coin.SoEventCallback_getClassTypeId()

def SoEventCallback_initClass():
  """SoEventCallback_initClass()"""
  return _coin.SoEventCallback_initClass()

class SoSelection(SoSeparator):
    """Proxy of C++ SoSelection class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSelection_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSelection_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoSelection_initClass()

    initClass = staticmethod(initClass)
    SINGLE = _coin.SoSelection_SINGLE
    TOGGLE = _coin.SoSelection_TOGGLE
    SHIFT = _coin.SoSelection_SHIFT
    policy = _swig_property(_coin.SoSelection_policy_get, _coin.SoSelection_policy_set)
    def __init__(self, *args): 
        """
        __init__(self) -> SoSelection
        __init__(self, int nChildren) -> SoSelection
        """
        this = _coin.new_SoSelection(*args)
        try: self.this.append(this)
        except: self.this = this
    def select(self, *args):
        """
        select(self, SoPath path)
        select(self, SoNode node)
        """
        return _coin.SoSelection_select(self, *args)

    def deselect(self, *args):
        """
        deselect(self, SoPath path)
        deselect(self, int which)
        deselect(self, SoNode node)
        """
        return _coin.SoSelection_deselect(self, *args)

    def toggle(self, *args):
        """
        toggle(self, SoPath path)
        toggle(self, SoNode node)
        """
        return _coin.SoSelection_toggle(self, *args)

    def isSelected(self, *args):
        """
        isSelected(self, SoPath path) -> SbBool
        isSelected(self, SoNode node) -> SbBool
        """
        return _coin.SoSelection_isSelected(self, *args)

    def deselectAll(self):
        """deselectAll(self)"""
        return _coin.SoSelection_deselectAll(self)

    def getNumSelected(self):
        """getNumSelected(self) -> int"""
        return _coin.SoSelection_getNumSelected(self)

    def getList(self):
        """getList(self) -> SoPathList"""
        return _coin.SoSelection_getList(self)

    def getPath(self, *args):
        """getPath(self, int index) -> SoPath"""
        return _coin.SoSelection_getPath(self, *args)

    def setPickMatching(self, *args):
        """setPickMatching(self, SbBool pickMatching)"""
        return _coin.SoSelection_setPickMatching(self, *args)

    def isPickMatching(self):
        """isPickMatching(self) -> SbBool"""
        return _coin.SoSelection_isPickMatching(self)

    def getPickMatching(self):
        """getPickMatching(self) -> SbBool"""
        return _coin.SoSelection_getPickMatching(self)

    def addSelectionCallback(self, *args):
        """
        addSelectionCallback(self, SoSelectionPathCB f, void userData = None)
        addSelectionCallback(self, SoSelectionPathCB f)
        addSelectionCallback(self, PyObject pyfunc, PyObject userdata = None)
        addSelectionCallback(self, PyObject pyfunc)
        """
        return _coin.SoSelection_addSelectionCallback(self, *args)

    def removeSelectionCallback(self, *args):
        """
        removeSelectionCallback(self, SoSelectionPathCB f, void userData = None)
        removeSelectionCallback(self, SoSelectionPathCB f)
        removeSelectionCallback(self, PyObject pyfunc, PyObject userdata = None)
        removeSelectionCallback(self, PyObject pyfunc)
        """
        return _coin.SoSelection_removeSelectionCallback(self, *args)

    def addDeselectionCallback(self, *args):
        """
        addDeselectionCallback(self, SoSelectionPathCB f, void userData = None)
        addDeselectionCallback(self, SoSelectionPathCB f)
        addDeselectionCallback(self, PyObject pyfunc, PyObject userdata = None)
        addDeselectionCallback(self, PyObject pyfunc)
        """
        return _coin.SoSelection_addDeselectionCallback(self, *args)

    def removeDeselectionCallback(self, *args):
        """
        removeDeselectionCallback(self, SoSelectionPathCB f, void userData = None)
        removeDeselectionCallback(self, SoSelectionPathCB f)
        removeDeselectionCallback(self, PyObject pyfunc, PyObject userdata = None)
        removeDeselectionCallback(self, PyObject pyfunc)
        """
        return _coin.SoSelection_removeDeselectionCallback(self, *args)

    def addStartCallback(self, *args):
        """
        addStartCallback(self, SoSelectionClassCB f, void userData = None)
        addStartCallback(self, SoSelectionClassCB f)
        addStartCallback(self, PyObject pyfunc, PyObject userdata = None)
        addStartCallback(self, PyObject pyfunc)
        """
        return _coin.SoSelection_addStartCallback(self, *args)

    def removeStartCallback(self, *args):
        """
        removeStartCallback(self, SoSelectionClassCB f, void userData = None)
        removeStartCallback(self, SoSelectionClassCB f)
        removeStartCallback(self, PyObject pyfunc, PyObject userdata = None)
        removeStartCallback(self, PyObject pyfunc)
        """
        return _coin.SoSelection_removeStartCallback(self, *args)

    def addFinishCallback(self, *args):
        """
        addFinishCallback(self, SoSelectionClassCB f, void userData = None)
        addFinishCallback(self, SoSelectionClassCB f)
        addFinishCallback(self, PyObject pyfunc, PyObject userdata = None)
        addFinishCallback(self, PyObject pyfunc)
        """
        return _coin.SoSelection_addFinishCallback(self, *args)

    def removeFinishCallback(self, *args):
        """
        removeFinishCallback(self, SoSelectionClassCB f, void userData = None)
        removeFinishCallback(self, SoSelectionClassCB f)
        removeFinishCallback(self, PyObject pyfunc, PyObject userdata = None)
        removeFinishCallback(self, PyObject pyfunc)
        """
        return _coin.SoSelection_removeFinishCallback(self, *args)

    def setPickFilterCallback(self, *args):
        """
        setPickFilterCallback(self, SoSelectionPickCB f, void userData = None, SbBool callOnlyIfSelectable = 1)
        setPickFilterCallback(self, SoSelectionPickCB f, void userData = None)
        setPickFilterCallback(self, SoSelectionPickCB f)
        setPickFilterCallback(self, PyObject pyfunc, PyObject userdata = None, int callOnlyIfSelectable = 1)
        setPickFilterCallback(self, PyObject pyfunc, PyObject userdata = None)
        setPickFilterCallback(self, PyObject pyfunc)
        """
        return _coin.SoSelection_setPickFilterCallback(self, *args)

    def addChangeCallback(self, *args):
        """
        addChangeCallback(self, SoSelectionClassCB f, void userData = None)
        addChangeCallback(self, SoSelectionClassCB f)
        addChangeCallback(self, PyObject pyfunc, PyObject userdata = None)
        addChangeCallback(self, PyObject pyfunc)
        """
        return _coin.SoSelection_addChangeCallback(self, *args)

    def removeChangeCallback(self, *args):
        """
        removeChangeCallback(self, SoSelectionClassCB f, void userData = None)
        removeChangeCallback(self, SoSelectionClassCB f)
        removeChangeCallback(self, PyObject pyfunc, PyObject userdata = None)
        removeChangeCallback(self, PyObject pyfunc)
        """
        return _coin.SoSelection_removeChangeCallback(self, *args)

SoSelection_swigregister = _coin.SoSelection_swigregister
SoSelection_swigregister(SoSelection)

def SoSelection_getClassTypeId():
  """SoSelection_getClassTypeId() -> SoType"""
  return _coin.SoSelection_getClassTypeId()

def SoSelection_initClass():
  """SoSelection_initClass()"""
  return _coin.SoSelection_initClass()

class SoExtSelection(SoSelection):
    """Proxy of C++ SoExtSelection class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoExtSelection_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoExtSelection_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoExtSelection_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoExtSelection"""
        this = _coin.new_SoExtSelection()
        try: self.this.append(this)
        except: self.this = this
    NOLASSO = _coin.SoExtSelection_NOLASSO
    LASSO = _coin.SoExtSelection_LASSO
    RECTANGLE = _coin.SoExtSelection_RECTANGLE
    FULL_BBOX = _coin.SoExtSelection_FULL_BBOX
    PART_BBOX = _coin.SoExtSelection_PART_BBOX
    FULL = _coin.SoExtSelection_FULL
    PART = _coin.SoExtSelection_PART
    ALL_SHAPES = _coin.SoExtSelection_ALL_SHAPES
    VISIBLE_SHAPES = _coin.SoExtSelection_VISIBLE_SHAPES
    lassoType = _swig_property(_coin.SoExtSelection_lassoType_get, _coin.SoExtSelection_lassoType_set)
    lassoPolicy = _swig_property(_coin.SoExtSelection_lassoPolicy_get, _coin.SoExtSelection_lassoPolicy_set)
    lassoMode = _swig_property(_coin.SoExtSelection_lassoMode_get, _coin.SoExtSelection_lassoMode_set)
    def useOverlay(self, overlay = 1):
        """
        useOverlay(self, SbBool overlay = 1)
        useOverlay(self)
        """
        return _coin.SoExtSelection_useOverlay(self, overlay)

    def isUsingOverlay(self):
        """isUsingOverlay(self) -> SbBool"""
        return _coin.SoExtSelection_isUsingOverlay(self)

    def getOverlaySceneGraph(self):
        """getOverlaySceneGraph(self) -> SoSeparator"""
        return _coin.SoExtSelection_getOverlaySceneGraph(self)

    def setOverlayLassoColorIndex(self, *args):
        """setOverlayLassoColorIndex(self, int index)"""
        return _coin.SoExtSelection_setOverlayLassoColorIndex(self, *args)

    def getOverlayLassoColorIndex(self):
        """getOverlayLassoColorIndex(self) -> int"""
        return _coin.SoExtSelection_getOverlayLassoColorIndex(self)

    def setLassoColor(self, *args):
        """setLassoColor(self, SbColor color)"""
        return _coin.SoExtSelection_setLassoColor(self, *args)

    def getLassoColor(self):
        """getLassoColor(self) -> SbColor"""
        return _coin.SoExtSelection_getLassoColor(self)

    def setLassoWidth(self, *args):
        """setLassoWidth(self, float width)"""
        return _coin.SoExtSelection_setLassoWidth(self, *args)

    def getLassoWidth(self):
        """getLassoWidth(self) -> float"""
        return _coin.SoExtSelection_getLassoWidth(self)

    def setOverlayLassoPattern(self, *args):
        """setOverlayLassoPattern(self, unsigned short pattern)"""
        return _coin.SoExtSelection_setOverlayLassoPattern(self, *args)

    def getOverlayLassoPattern(self):
        """getOverlayLassoPattern(self) -> unsigned short"""
        return _coin.SoExtSelection_getOverlayLassoPattern(self)

    def animateOverlayLasso(self, animate = 1):
        """
        animateOverlayLasso(self, SbBool animate = 1)
        animateOverlayLasso(self)
        """
        return _coin.SoExtSelection_animateOverlayLasso(self, animate)

    def isOverlayLassoAnimated(self):
        """isOverlayLassoAnimated(self) -> SbBool"""
        return _coin.SoExtSelection_isOverlayLassoAnimated(self)

    def handleEvent(self, *args):
        """handleEvent(self, SoHandleEventAction action)"""
        return _coin.SoExtSelection_handleEvent(self, *args)

    def GLRenderBelowPath(self, *args):
        """GLRenderBelowPath(self, SoGLRenderAction action)"""
        return _coin.SoExtSelection_GLRenderBelowPath(self, *args)

    def select(self, *args):
        """
        select(self, SoNode root, int numcoords, SbVec2f lasso, SbViewportRegion vp, 
            SbBool shiftpolicy)
        select(self, SoNode root, int numcoords, SbVec3f lasso, SbViewportRegion vp, 
            SbBool shiftkeypolicy)
        """
        return _coin.SoExtSelection_select(self, *args)

    def getLassoCoordsDC(self, *args):
        """getLassoCoordsDC(self, int numCoords) -> SbVec2s"""
        return _coin.SoExtSelection_getLassoCoordsDC(self, *args)

    def getLassoCoordsWC(self, *args):
        """getLassoCoordsWC(self, int numCoords) -> SbVec3f"""
        return _coin.SoExtSelection_getLassoCoordsWC(self, *args)

    def getSelectionPathList(self):
        """getSelectionPathList(self) -> SoPathList"""
        return _coin.SoExtSelection_getSelectionPathList(self)

    def setLassoFilterCallback(self, *args):
        """
        setLassoFilterCallback(self, SoLassoSelectionFilterCB f, void userdata = None, SbBool callonlyifselectable = 1)
        setLassoFilterCallback(self, SoLassoSelectionFilterCB f, void userdata = None)
        setLassoFilterCallback(self, SoLassoSelectionFilterCB f)
        """
        return _coin.SoExtSelection_setLassoFilterCallback(self, *args)

    def setTriangleFilterCallback(self, *args):
        """
        setTriangleFilterCallback(self, SoExtSelectionTriangleCB func, void userdata = None)
        setTriangleFilterCallback(self, SoExtSelectionTriangleCB func)
        """
        return _coin.SoExtSelection_setTriangleFilterCallback(self, *args)

    def setLineSegmentFilterCallback(self, *args):
        """
        setLineSegmentFilterCallback(self, SoExtSelectionLineSegmentCB func, void userdata = None)
        setLineSegmentFilterCallback(self, SoExtSelectionLineSegmentCB func)
        """
        return _coin.SoExtSelection_setLineSegmentFilterCallback(self, *args)

    def setPointFilterCallback(self, *args):
        """
        setPointFilterCallback(self, SoExtSelectionPointCB func, void userdata = None)
        setPointFilterCallback(self, SoExtSelectionPointCB func)
        """
        return _coin.SoExtSelection_setPointFilterCallback(self, *args)

    def wasShiftDown(self):
        """wasShiftDown(self) -> SbBool"""
        return _coin.SoExtSelection_wasShiftDown(self)

SoExtSelection_swigregister = _coin.SoExtSelection_swigregister
SoExtSelection_swigregister(SoExtSelection)

def SoExtSelection_getClassTypeId():
  """SoExtSelection_getClassTypeId() -> SoType"""
  return _coin.SoExtSelection_getClassTypeId()

def SoExtSelection_initClass():
  """SoExtSelection_initClass()"""
  return _coin.SoExtSelection_initClass()

class SoVertexProperty(SoNode):
    """Proxy of C++ SoVertexProperty class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVertexProperty_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVertexProperty_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVertexProperty_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVertexProperty"""
        this = _coin.new_SoVertexProperty()
        try: self.this.append(this)
        except: self.this = this
    OVERALL = _coin.SoVertexProperty_OVERALL
    PER_PART = _coin.SoVertexProperty_PER_PART
    PER_PART_INDEXED = _coin.SoVertexProperty_PER_PART_INDEXED
    PER_FACE = _coin.SoVertexProperty_PER_FACE
    PER_FACE_INDEXED = _coin.SoVertexProperty_PER_FACE_INDEXED
    PER_VERTEX = _coin.SoVertexProperty_PER_VERTEX
    PER_VERTEX_INDEXED = _coin.SoVertexProperty_PER_VERTEX_INDEXED
    vertex = _swig_property(_coin.SoVertexProperty_vertex_get, _coin.SoVertexProperty_vertex_set)
    texCoord = _swig_property(_coin.SoVertexProperty_texCoord_get, _coin.SoVertexProperty_texCoord_set)
    texCoord3 = _swig_property(_coin.SoVertexProperty_texCoord3_get, _coin.SoVertexProperty_texCoord3_set)
    normal = _swig_property(_coin.SoVertexProperty_normal_get, _coin.SoVertexProperty_normal_set)
    normalBinding = _swig_property(_coin.SoVertexProperty_normalBinding_get, _coin.SoVertexProperty_normalBinding_set)
    orderedRGBA = _swig_property(_coin.SoVertexProperty_orderedRGBA_get, _coin.SoVertexProperty_orderedRGBA_set)
    materialBinding = _swig_property(_coin.SoVertexProperty_materialBinding_get, _coin.SoVertexProperty_materialBinding_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoVertexProperty_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVertexProperty_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoVertexProperty_getBoundingBox(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoVertexProperty_callback(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoVertexProperty_pick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVertexProperty_getPrimitiveCount(self, *args)

SoVertexProperty_swigregister = _coin.SoVertexProperty_swigregister
SoVertexProperty_swigregister(SoVertexProperty)

def SoVertexProperty_getClassTypeId():
  """SoVertexProperty_getClassTypeId() -> SoType"""
  return _coin.SoVertexProperty_getClassTypeId()

def SoVertexProperty_initClass():
  """SoVertexProperty_initClass()"""
  return _coin.SoVertexProperty_initClass()

class SoVertexShape(SoShape):
    """Proxy of C++ SoVertexShape class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVertexShape_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVertexShape_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVertexShape_initClass()

    initClass = staticmethod(initClass)
    vertexProperty = _swig_property(_coin.SoVertexShape_vertexProperty_get, _coin.SoVertexShape_vertexProperty_set)
    def notify(self, *args):
        """notify(self, SoNotList nl)"""
        return _coin.SoVertexShape_notify(self, *args)

    def generateDefaultNormals(self, *args):
        """
        generateDefaultNormals(self, SoState state, SoNormalBundle bundle) -> SbBool
        generateDefaultNormals(self, SoState state, SoNormalCache cache) -> SbBool
        """
        return _coin.SoVertexShape_generateDefaultNormals(self, *args)

    def write(self, *args):
        """write(self, SoWriteAction action)"""
        return _coin.SoVertexShape_write(self, *args)

SoVertexShape_swigregister = _coin.SoVertexShape_swigregister
SoVertexShape_swigregister(SoVertexShape)

def SoVertexShape_getClassTypeId():
  """SoVertexShape_getClassTypeId() -> SoType"""
  return _coin.SoVertexShape_getClassTypeId()

def SoVertexShape_initClass():
  """SoVertexShape_initClass()"""
  return _coin.SoVertexShape_initClass()

class SoNonIndexedShape(SoVertexShape):
    """Proxy of C++ SoNonIndexedShape class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoNonIndexedShape_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoNonIndexedShape_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoNonIndexedShape_initClass()

    initClass = staticmethod(initClass)
    startIndex = _swig_property(_coin.SoNonIndexedShape_startIndex_get, _coin.SoNonIndexedShape_startIndex_set)
SoNonIndexedShape_swigregister = _coin.SoNonIndexedShape_swigregister
SoNonIndexedShape_swigregister(SoNonIndexedShape)

def SoNonIndexedShape_getClassTypeId():
  """SoNonIndexedShape_getClassTypeId() -> SoType"""
  return _coin.SoNonIndexedShape_getClassTypeId()

def SoNonIndexedShape_initClass():
  """SoNonIndexedShape_initClass()"""
  return _coin.SoNonIndexedShape_initClass()

class SoFaceSet(SoNonIndexedShape):
    """Proxy of C++ SoFaceSet class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoFaceSet_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoFaceSet_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoFaceSet_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoFaceSet"""
        this = _coin.new_SoFaceSet()
        try: self.this.append(this)
        except: self.this = this
    numVertices = _swig_property(_coin.SoFaceSet_numVertices_get, _coin.SoFaceSet_numVertices_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoFaceSet_GLRender(self, *args)

    def generateDefaultNormals(self, *args):
        """generateDefaultNormals(self, SoState state, SoNormalBundle nb) -> SbBool"""
        return _coin.SoFaceSet_generateDefaultNormals(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoFaceSet_getPrimitiveCount(self, *args)

SoFaceSet_swigregister = _coin.SoFaceSet_swigregister
SoFaceSet_swigregister(SoFaceSet)

def SoFaceSet_getClassTypeId():
  """SoFaceSet_getClassTypeId() -> SoType"""
  return _coin.SoFaceSet_getClassTypeId()

def SoFaceSet_initClass():
  """SoFaceSet_initClass()"""
  return _coin.SoFaceSet_initClass()

class SoFile(SoNode):
    """Proxy of C++ SoFile class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoFile_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoFile_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoFile_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoFile"""
        this = _coin.new_SoFile()
        try: self.this.append(this)
        except: self.this = this
    name = _swig_property(_coin.SoFile_name_get, _coin.SoFile_name_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoFile_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoFile_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoFile_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoFile_getBoundingBox(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoFile_getMatrix(self, *args)

    def handleEvent(self, *args):
        """handleEvent(self, SoHandleEventAction action)"""
        return _coin.SoFile_handleEvent(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoFile_pick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoFile_getPrimitiveCount(self, *args)

    def audioRender(self, *args):
        """audioRender(self, SoAudioRenderAction action)"""
        return _coin.SoFile_audioRender(self, *args)

    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoFile_search(self, *args)

    def copyChildren(self):
        """copyChildren(self) -> SoGroup"""
        return _coin.SoFile_copyChildren(self)

    def getChildren(self):
        """getChildren(self) -> SoChildList"""
        return _coin.SoFile_getChildren(self)

    def copyContents(self, *args):
        """copyContents(self, SoFieldContainer srcFrom, SbBool copyconnections)"""
        return _coin.SoFile_copyContents(self, *args)

    def getFullName(self):
        """getFullName(self) -> SbString"""
        return _coin.SoFile_getFullName(self)

    def setSearchOK(*args):
        """setSearchOK(SbBool dosearch)"""
        return _coin.SoFile_setSearchOK(*args)

    setSearchOK = staticmethod(setSearchOK)
    def getSearchOK():
        """getSearchOK() -> SbBool"""
        return _coin.SoFile_getSearchOK()

    getSearchOK = staticmethod(getSearchOK)
SoFile_swigregister = _coin.SoFile_swigregister
SoFile_swigregister(SoFile)

def SoFile_getClassTypeId():
  """SoFile_getClassTypeId() -> SoType"""
  return _coin.SoFile_getClassTypeId()

def SoFile_initClass():
  """SoFile_initClass()"""
  return _coin.SoFile_initClass()

def SoFile_setSearchOK(*args):
  """SoFile_setSearchOK(SbBool dosearch)"""
  return _coin.SoFile_setSearchOK(*args)

def SoFile_getSearchOK():
  """SoFile_getSearchOK() -> SbBool"""
  return _coin.SoFile_getSearchOK()

class SoFont(SoNode):
    """Proxy of C++ SoFont class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoFont_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoFont_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoFont_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoFont"""
        this = _coin.new_SoFont()
        try: self.this.append(this)
        except: self.this = this
    name = _swig_property(_coin.SoFont_name_get, _coin.SoFont_name_set)
    size = _swig_property(_coin.SoFont_size_get, _coin.SoFont_size_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoFont_doAction(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoFont_getBoundingBox(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoFont_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoFont_callback(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoFont_pick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoFont_getPrimitiveCount(self, *args)

SoFont_swigregister = _coin.SoFont_swigregister
SoFont_swigregister(SoFont)

def SoFont_getClassTypeId():
  """SoFont_getClassTypeId() -> SoType"""
  return _coin.SoFont_getClassTypeId()

def SoFont_initClass():
  """SoFont_initClass()"""
  return _coin.SoFont_initClass()

class SoFontStyle(SoFont):
    """Proxy of C++ SoFontStyle class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoFontStyle_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoFontStyle_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoFontStyle_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoFontStyle"""
        this = _coin.new_SoFontStyle()
        try: self.this.append(this)
        except: self.this = this
    SERIF = _coin.SoFontStyle_SERIF
    SANS = _coin.SoFontStyle_SANS
    TYPEWRITER = _coin.SoFontStyle_TYPEWRITER
    NONE = _coin.SoFontStyle_NONE
    BOLD = _coin.SoFontStyle_BOLD
    ITALIC = _coin.SoFontStyle_ITALIC
    family = _swig_property(_coin.SoFontStyle_family_get, _coin.SoFontStyle_family_set)
    style = _swig_property(_coin.SoFontStyle_style_get, _coin.SoFontStyle_style_set)
    def getFontName(self):
        """getFontName(self) -> SbString"""
        return _coin.SoFontStyle_getFontName(self)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoFontStyle_doAction(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoFontStyle_getBoundingBox(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoFontStyle_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoFontStyle_callback(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoFontStyle_pick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoFontStyle_getPrimitiveCount(self, *args)

SoFontStyle_swigregister = _coin.SoFontStyle_swigregister
SoFontStyle_swigregister(SoFontStyle)

def SoFontStyle_getClassTypeId():
  """SoFontStyle_getClassTypeId() -> SoType"""
  return _coin.SoFontStyle_getClassTypeId()

def SoFontStyle_initClass():
  """SoFontStyle_initClass()"""
  return _coin.SoFontStyle_initClass()

class SoIndexedShape(SoVertexShape):
    """Proxy of C++ SoIndexedShape class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoIndexedShape_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoIndexedShape_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoIndexedShape_initClass()

    initClass = staticmethod(initClass)
    coordIndex = _swig_property(_coin.SoIndexedShape_coordIndex_get, _coin.SoIndexedShape_coordIndex_set)
    materialIndex = _swig_property(_coin.SoIndexedShape_materialIndex_get, _coin.SoIndexedShape_materialIndex_set)
    normalIndex = _swig_property(_coin.SoIndexedShape_normalIndex_get, _coin.SoIndexedShape_normalIndex_set)
    textureCoordIndex = _swig_property(_coin.SoIndexedShape_textureCoordIndex_get, _coin.SoIndexedShape_textureCoordIndex_set)
SoIndexedShape_swigregister = _coin.SoIndexedShape_swigregister
SoIndexedShape_swigregister(SoIndexedShape)

def SoIndexedShape_getClassTypeId():
  """SoIndexedShape_getClassTypeId() -> SoType"""
  return _coin.SoIndexedShape_getClassTypeId()

def SoIndexedShape_initClass():
  """SoIndexedShape_initClass()"""
  return _coin.SoIndexedShape_initClass()

SO_END_FACE_INDEX = _coin.SO_END_FACE_INDEX
class SoIndexedFaceSet(SoIndexedShape):
    """Proxy of C++ SoIndexedFaceSet class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoIndexedFaceSet_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoIndexedFaceSet_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoIndexedFaceSet_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoIndexedFaceSet"""
        this = _coin.new_SoIndexedFaceSet()
        try: self.this.append(this)
        except: self.this = this
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoIndexedFaceSet_GLRender(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoIndexedFaceSet_getPrimitiveCount(self, *args)

    def generateDefaultNormals(self, *args):
        """
        generateDefaultNormals(self, SoState state, SoNormalBundle bundle) -> SbBool
        generateDefaultNormals(self, SoState state, SoNormalCache cache) -> SbBool
        """
        return _coin.SoIndexedFaceSet_generateDefaultNormals(self, *args)

SoIndexedFaceSet_swigregister = _coin.SoIndexedFaceSet_swigregister
SoIndexedFaceSet_swigregister(SoIndexedFaceSet)

def SoIndexedFaceSet_getClassTypeId():
  """SoIndexedFaceSet_getClassTypeId() -> SoType"""
  return _coin.SoIndexedFaceSet_getClassTypeId()

def SoIndexedFaceSet_initClass():
  """SoIndexedFaceSet_initClass()"""
  return _coin.SoIndexedFaceSet_initClass()

SO_END_LINE_INDEX = _coin.SO_END_LINE_INDEX
class SoIndexedLineSet(SoIndexedShape):
    """Proxy of C++ SoIndexedLineSet class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoIndexedLineSet_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoIndexedLineSet_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoIndexedLineSet_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoIndexedLineSet"""
        this = _coin.new_SoIndexedLineSet()
        try: self.this.append(this)
        except: self.this = this
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoIndexedLineSet_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoIndexedLineSet_getBoundingBox(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoIndexedLineSet_getPrimitiveCount(self, *args)

SoIndexedLineSet_swigregister = _coin.SoIndexedLineSet_swigregister
SoIndexedLineSet_swigregister(SoIndexedLineSet)

def SoIndexedLineSet_getClassTypeId():
  """SoIndexedLineSet_getClassTypeId() -> SoType"""
  return _coin.SoIndexedLineSet_getClassTypeId()

def SoIndexedLineSet_initClass():
  """SoIndexedLineSet_initClass()"""
  return _coin.SoIndexedLineSet_initClass()

class SoIndexedNurbsCurve(SoShape):
    """Proxy of C++ SoIndexedNurbsCurve class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoIndexedNurbsCurve_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoIndexedNurbsCurve_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoIndexedNurbsCurve_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoIndexedNurbsCurve"""
        this = _coin.new_SoIndexedNurbsCurve()
        try: self.this.append(this)
        except: self.this = this
    numControlPoints = _swig_property(_coin.SoIndexedNurbsCurve_numControlPoints_get, _coin.SoIndexedNurbsCurve_numControlPoints_set)
    coordIndex = _swig_property(_coin.SoIndexedNurbsCurve_coordIndex_get, _coin.SoIndexedNurbsCurve_coordIndex_set)
    knotVector = _swig_property(_coin.SoIndexedNurbsCurve_knotVector_get, _coin.SoIndexedNurbsCurve_knotVector_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoIndexedNurbsCurve_GLRender(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoIndexedNurbsCurve_rayPick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoIndexedNurbsCurve_getPrimitiveCount(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoIndexedNurbsCurve_getBoundingBox(self, *args)

    def sendPrimitive(self, *args):
        """sendPrimitive(self, SoAction arg0, SoPrimitiveVertex arg1)"""
        return _coin.SoIndexedNurbsCurve_sendPrimitive(self, *args)

SoIndexedNurbsCurve_swigregister = _coin.SoIndexedNurbsCurve_swigregister
SoIndexedNurbsCurve_swigregister(SoIndexedNurbsCurve)

def SoIndexedNurbsCurve_getClassTypeId():
  """SoIndexedNurbsCurve_getClassTypeId() -> SoType"""
  return _coin.SoIndexedNurbsCurve_getClassTypeId()

def SoIndexedNurbsCurve_initClass():
  """SoIndexedNurbsCurve_initClass()"""
  return _coin.SoIndexedNurbsCurve_initClass()

class SoIndexedNurbsSurface(SoShape):
    """Proxy of C++ SoIndexedNurbsSurface class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoIndexedNurbsSurface_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoIndexedNurbsSurface_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoIndexedNurbsSurface_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoIndexedNurbsSurface"""
        this = _coin.new_SoIndexedNurbsSurface()
        try: self.this.append(this)
        except: self.this = this
    numUControlPoints = _swig_property(_coin.SoIndexedNurbsSurface_numUControlPoints_get, _coin.SoIndexedNurbsSurface_numUControlPoints_set)
    numVControlPoints = _swig_property(_coin.SoIndexedNurbsSurface_numVControlPoints_get, _coin.SoIndexedNurbsSurface_numVControlPoints_set)
    coordIndex = _swig_property(_coin.SoIndexedNurbsSurface_coordIndex_get, _coin.SoIndexedNurbsSurface_coordIndex_set)
    uKnotVector = _swig_property(_coin.SoIndexedNurbsSurface_uKnotVector_get, _coin.SoIndexedNurbsSurface_uKnotVector_set)
    vKnotVector = _swig_property(_coin.SoIndexedNurbsSurface_vKnotVector_get, _coin.SoIndexedNurbsSurface_vKnotVector_set)
    numSControlPoints = _swig_property(_coin.SoIndexedNurbsSurface_numSControlPoints_get, _coin.SoIndexedNurbsSurface_numSControlPoints_set)
    numTControlPoints = _swig_property(_coin.SoIndexedNurbsSurface_numTControlPoints_get, _coin.SoIndexedNurbsSurface_numTControlPoints_set)
    textureCoordIndex = _swig_property(_coin.SoIndexedNurbsSurface_textureCoordIndex_get, _coin.SoIndexedNurbsSurface_textureCoordIndex_set)
    sKnotVector = _swig_property(_coin.SoIndexedNurbsSurface_sKnotVector_get, _coin.SoIndexedNurbsSurface_sKnotVector_set)
    tKnotVector = _swig_property(_coin.SoIndexedNurbsSurface_tKnotVector_get, _coin.SoIndexedNurbsSurface_tKnotVector_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoIndexedNurbsSurface_GLRender(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoIndexedNurbsSurface_rayPick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoIndexedNurbsSurface_getPrimitiveCount(self, *args)

    def sendPrimitive(self, *args):
        """sendPrimitive(self, SoAction arg0, SoPrimitiveVertex arg1)"""
        return _coin.SoIndexedNurbsSurface_sendPrimitive(self, *args)

SoIndexedNurbsSurface_swigregister = _coin.SoIndexedNurbsSurface_swigregister
SoIndexedNurbsSurface_swigregister(SoIndexedNurbsSurface)

def SoIndexedNurbsSurface_getClassTypeId():
  """SoIndexedNurbsSurface_getClassTypeId() -> SoType"""
  return _coin.SoIndexedNurbsSurface_getClassTypeId()

def SoIndexedNurbsSurface_initClass():
  """SoIndexedNurbsSurface_initClass()"""
  return _coin.SoIndexedNurbsSurface_initClass()

SO_END_STRIP_INDEX = _coin.SO_END_STRIP_INDEX
class SoIndexedTriangleStripSet(SoIndexedShape):
    """Proxy of C++ SoIndexedTriangleStripSet class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoIndexedTriangleStripSet_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoIndexedTriangleStripSet_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoIndexedTriangleStripSet_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoIndexedTriangleStripSet"""
        this = _coin.new_SoIndexedTriangleStripSet()
        try: self.this.append(this)
        except: self.this = this
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoIndexedTriangleStripSet_GLRender(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoIndexedTriangleStripSet_getPrimitiveCount(self, *args)

    def generateDefaultNormals(self, *args):
        """generateDefaultNormals(self, SoState state, SoNormalBundle nb) -> SbBool"""
        return _coin.SoIndexedTriangleStripSet_generateDefaultNormals(self, *args)

SoIndexedTriangleStripSet_swigregister = _coin.SoIndexedTriangleStripSet_swigregister
SoIndexedTriangleStripSet_swigregister(SoIndexedTriangleStripSet)

def SoIndexedTriangleStripSet_getClassTypeId():
  """SoIndexedTriangleStripSet_getClassTypeId() -> SoType"""
  return _coin.SoIndexedTriangleStripSet_getClassTypeId()

def SoIndexedTriangleStripSet_initClass():
  """SoIndexedTriangleStripSet_initClass()"""
  return _coin.SoIndexedTriangleStripSet_initClass()

class SoInfo(SoNode):
    """Proxy of C++ SoInfo class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoInfo_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoInfo_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoInfo_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoInfo"""
        this = _coin.new_SoInfo()
        try: self.this.append(this)
        except: self.this = this
    string = _swig_property(_coin.SoInfo_string_get, _coin.SoInfo_string_set)
SoInfo_swigregister = _coin.SoInfo_swigregister
SoInfo_swigregister(SoInfo)

def SoInfo_getClassTypeId():
  """SoInfo_getClassTypeId() -> SoType"""
  return _coin.SoInfo_getClassTypeId()

def SoInfo_initClass():
  """SoInfo_initClass()"""
  return _coin.SoInfo_initClass()

class SoLabel(SoNode):
    """Proxy of C++ SoLabel class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoLabel_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoLabel_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoLabel_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoLabel"""
        this = _coin.new_SoLabel()
        try: self.this.append(this)
        except: self.this = this
    label = _swig_property(_coin.SoLabel_label_get, _coin.SoLabel_label_set)
SoLabel_swigregister = _coin.SoLabel_swigregister
SoLabel_swigregister(SoLabel)

def SoLabel_getClassTypeId():
  """SoLabel_getClassTypeId() -> SoType"""
  return _coin.SoLabel_getClassTypeId()

def SoLabel_initClass():
  """SoLabel_initClass()"""
  return _coin.SoLabel_initClass()

class SoLevelOfDetail(SoGroup):
    """Proxy of C++ SoLevelOfDetail class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoLevelOfDetail_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoLevelOfDetail_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoLevelOfDetail_initClass()

    initClass = staticmethod(initClass)
    def __init__(self, *args): 
        """
        __init__(self) -> SoLevelOfDetail
        __init__(self, int numchildren) -> SoLevelOfDetail
        """
        this = _coin.new_SoLevelOfDetail(*args)
        try: self.this.append(this)
        except: self.this = this
    screenArea = _swig_property(_coin.SoLevelOfDetail_screenArea_get, _coin.SoLevelOfDetail_screenArea_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoLevelOfDetail_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoLevelOfDetail_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoLevelOfDetail_GLRender(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoLevelOfDetail_rayPick(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoLevelOfDetail_getBoundingBox(self, *args)

    def audioRender(self, *args):
        """audioRender(self, SoAudioRenderAction action)"""
        return _coin.SoLevelOfDetail_audioRender(self, *args)

    def notify(self, *args):
        """notify(self, SoNotList nl)"""
        return _coin.SoLevelOfDetail_notify(self, *args)

SoLevelOfDetail_swigregister = _coin.SoLevelOfDetail_swigregister
SoLevelOfDetail_swigregister(SoLevelOfDetail)

def SoLevelOfDetail_getClassTypeId():
  """SoLevelOfDetail_getClassTypeId() -> SoType"""
  return _coin.SoLevelOfDetail_getClassTypeId()

def SoLevelOfDetail_initClass():
  """SoLevelOfDetail_initClass()"""
  return _coin.SoLevelOfDetail_initClass()

class SoProfile(SoNode):
    """Proxy of C++ SoProfile class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoProfile_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoProfile_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoProfile_initClass()

    initClass = staticmethod(initClass)
    START_FIRST = _coin.SoProfile_START_FIRST
    START_NEW = _coin.SoProfile_START_NEW
    ADD_TO_CURRENT = _coin.SoProfile_ADD_TO_CURRENT
    index = _swig_property(_coin.SoProfile_index_get, _coin.SoProfile_index_set)
    linkage = _swig_property(_coin.SoProfile_linkage_get, _coin.SoProfile_linkage_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoProfile_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoProfile_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoProfile_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoProfile_getBoundingBox(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoProfile_pick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoProfile_getPrimitiveCount(self, *args)

    def getTrimCurve(self, *args):
        """
        getTrimCurve(self, SoState state, int32_t numpoints, float points, int floatspervec, 
            int32_t numknots, float knotvector)
        """
        return _coin.SoProfile_getTrimCurve(self, *args)

    def getVertices(self, *args):
        """getVertices(self, SoState state, int32_t numvertices, SbVec2f vertices)"""
        return _coin.SoProfile_getVertices(self, *args)

SoProfile_swigregister = _coin.SoProfile_swigregister
SoProfile_swigregister(SoProfile)

def SoProfile_getClassTypeId():
  """SoProfile_getClassTypeId() -> SoType"""
  return _coin.SoProfile_getClassTypeId()

def SoProfile_initClass():
  """SoProfile_initClass()"""
  return _coin.SoProfile_initClass()

class SoLinearProfile(SoProfile):
    """Proxy of C++ SoLinearProfile class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoLinearProfile_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoLinearProfile_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoLinearProfile_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoLinearProfile"""
        this = _coin.new_SoLinearProfile()
        try: self.this.append(this)
        except: self.this = this
    def getTrimCurve(self, *args):
        """
        getTrimCurve(self, SoState state, int32_t numpoints, float points, int floatspervec, 
            int32_t numknots, float knotvector)
        """
        return _coin.SoLinearProfile_getTrimCurve(self, *args)

    def getVertices(self, *args):
        """getVertices(self, SoState state, int32_t numvertices, SbVec2f vertices)"""
        return _coin.SoLinearProfile_getVertices(self, *args)

SoLinearProfile_swigregister = _coin.SoLinearProfile_swigregister
SoLinearProfile_swigregister(SoLinearProfile)

def SoLinearProfile_getClassTypeId():
  """SoLinearProfile_getClassTypeId() -> SoType"""
  return _coin.SoLinearProfile_getClassTypeId()

def SoLinearProfile_initClass():
  """SoLinearProfile_initClass()"""
  return _coin.SoLinearProfile_initClass()

class SoLineSet(SoNonIndexedShape):
    """Proxy of C++ SoLineSet class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoLineSet_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoLineSet_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoLineSet_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoLineSet"""
        this = _coin.new_SoLineSet()
        try: self.this.append(this)
        except: self.this = this
    numVertices = _swig_property(_coin.SoLineSet_numVertices_get, _coin.SoLineSet_numVertices_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoLineSet_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoLineSet_getBoundingBox(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoLineSet_getPrimitiveCount(self, *args)

SoLineSet_swigregister = _coin.SoLineSet_swigregister
SoLineSet_swigregister(SoLineSet)

def SoLineSet_getClassTypeId():
  """SoLineSet_getClassTypeId() -> SoType"""
  return _coin.SoLineSet_getClassTypeId()

def SoLineSet_initClass():
  """SoLineSet_initClass()"""
  return _coin.SoLineSet_initClass()

class SoListener(SoNode):
    """Proxy of C++ SoListener class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoListener_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoListener_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoListener_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoListener"""
        this = _coin.new_SoListener()
        try: self.this.append(this)
        except: self.this = this
    position = _swig_property(_coin.SoListener_position_get, _coin.SoListener_position_set)
    orientation = _swig_property(_coin.SoListener_orientation_get, _coin.SoListener_orientation_set)
    gain = _swig_property(_coin.SoListener_gain_get, _coin.SoListener_gain_set)
    dopplerVelocity = _swig_property(_coin.SoListener_dopplerVelocity_get, _coin.SoListener_dopplerVelocity_set)
    dopplerFactor = _swig_property(_coin.SoListener_dopplerFactor_get, _coin.SoListener_dopplerFactor_set)
SoListener_swigregister = _coin.SoListener_swigregister
SoListener_swigregister(SoListener)

def SoListener_getClassTypeId():
  """SoListener_getClassTypeId() -> SoType"""
  return _coin.SoListener_getClassTypeId()

def SoListener_initClass():
  """SoListener_initClass()"""
  return _coin.SoListener_initClass()

class SoLocateHighlight(SoSeparator):
    """Proxy of C++ SoLocateHighlight class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoLocateHighlight_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoLocateHighlight_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoLocateHighlight_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoLocateHighlight"""
        this = _coin.new_SoLocateHighlight()
        try: self.this.append(this)
        except: self.this = this
    AUTO = _coin.SoLocateHighlight_AUTO
    ON = _coin.SoLocateHighlight_ON
    OFF = _coin.SoLocateHighlight_OFF
    EMISSIVE = _coin.SoLocateHighlight_EMISSIVE
    EMISSIVE_DIFFUSE = _coin.SoLocateHighlight_EMISSIVE_DIFFUSE
    color = _swig_property(_coin.SoLocateHighlight_color_get, _coin.SoLocateHighlight_color_set)
    style = _swig_property(_coin.SoLocateHighlight_style_get, _coin.SoLocateHighlight_style_set)
    mode = _swig_property(_coin.SoLocateHighlight_mode_get, _coin.SoLocateHighlight_mode_set)
    def handleEvent(self, *args):
        """handleEvent(self, SoHandleEventAction action)"""
        return _coin.SoLocateHighlight_handleEvent(self, *args)

    def GLRenderBelowPath(self, *args):
        """GLRenderBelowPath(self, SoGLRenderAction action)"""
        return _coin.SoLocateHighlight_GLRenderBelowPath(self, *args)

    def GLRenderInPath(self, *args):
        """GLRenderInPath(self, SoGLRenderAction action)"""
        return _coin.SoLocateHighlight_GLRenderInPath(self, *args)

    def turnOffCurrentHighlight(*args):
        """turnOffCurrentHighlight(SoGLRenderAction action)"""
        return _coin.SoLocateHighlight_turnOffCurrentHighlight(*args)

    turnOffCurrentHighlight = staticmethod(turnOffCurrentHighlight)
SoLocateHighlight_swigregister = _coin.SoLocateHighlight_swigregister
SoLocateHighlight_swigregister(SoLocateHighlight)

def SoLocateHighlight_getClassTypeId():
  """SoLocateHighlight_getClassTypeId() -> SoType"""
  return _coin.SoLocateHighlight_getClassTypeId()

def SoLocateHighlight_initClass():
  """SoLocateHighlight_initClass()"""
  return _coin.SoLocateHighlight_initClass()

def SoLocateHighlight_turnOffCurrentHighlight(*args):
  """SoLocateHighlight_turnOffCurrentHighlight(SoGLRenderAction action)"""
  return _coin.SoLocateHighlight_turnOffCurrentHighlight(*args)

class SoLOD(SoGroup):
    """Proxy of C++ SoLOD class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoLOD_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoLOD_getTypeId(self)

    def __init__(self, *args): 
        """
        __init__(self) -> SoLOD
        __init__(self, int numchildren) -> SoLOD
        """
        this = _coin.new_SoLOD(*args)
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoLOD_initClass()

    initClass = staticmethod(initClass)
    range = _swig_property(_coin.SoLOD_range_get, _coin.SoLOD_range_set)
    center = _swig_property(_coin.SoLOD_center_get, _coin.SoLOD_center_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoLOD_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoLOD_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoLOD_GLRender(self, *args)

    def GLRenderBelowPath(self, *args):
        """GLRenderBelowPath(self, SoGLRenderAction action)"""
        return _coin.SoLOD_GLRenderBelowPath(self, *args)

    def GLRenderInPath(self, *args):
        """GLRenderInPath(self, SoGLRenderAction action)"""
        return _coin.SoLOD_GLRenderInPath(self, *args)

    def GLRenderOffPath(self, *args):
        """GLRenderOffPath(self, SoGLRenderAction action)"""
        return _coin.SoLOD_GLRenderOffPath(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoLOD_rayPick(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoLOD_getBoundingBox(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoLOD_getPrimitiveCount(self, *args)

    def audioRender(self, *args):
        """audioRender(self, SoAudioRenderAction action)"""
        return _coin.SoLOD_audioRender(self, *args)

    def notify(self, *args):
        """notify(self, SoNotList nl)"""
        return _coin.SoLOD_notify(self, *args)

SoLOD_swigregister = _coin.SoLOD_swigregister
SoLOD_swigregister(SoLOD)

def SoLOD_getClassTypeId():
  """SoLOD_getClassTypeId() -> SoType"""
  return _coin.SoLOD_getClassTypeId()

def SoLOD_initClass():
  """SoLOD_initClass()"""
  return _coin.SoLOD_initClass()

class SoPointSet(SoNonIndexedShape):
    """Proxy of C++ SoPointSet class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoPointSet_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoPointSet_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoPointSet_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoPointSet"""
        this = _coin.new_SoPointSet()
        try: self.this.append(this)
        except: self.this = this
    numPoints = _swig_property(_coin.SoPointSet_numPoints_get, _coin.SoPointSet_numPoints_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoPointSet_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoPointSet_getBoundingBox(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoPointSet_getPrimitiveCount(self, *args)

SoPointSet_swigregister = _coin.SoPointSet_swigregister
SoPointSet_swigregister(SoPointSet)

def SoPointSet_getClassTypeId():
  """SoPointSet_getClassTypeId() -> SoType"""
  return _coin.SoPointSet_getClassTypeId()

def SoPointSet_initClass():
  """SoPointSet_initClass()"""
  return _coin.SoPointSet_initClass()

class SoMarkerSet(SoPointSet):
    """Proxy of C++ SoMarkerSet class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMarkerSet_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMarkerSet_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoMarkerSet_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoMarkerSet"""
        this = _coin.new_SoMarkerSet()
        try: self.this.append(this)
        except: self.this = this
    NONE = _coin.SoMarkerSet_NONE
    CROSS_5_5 = _coin.SoMarkerSet_CROSS_5_5
    PLUS_5_5 = _coin.SoMarkerSet_PLUS_5_5
    MINUS_5_5 = _coin.SoMarkerSet_MINUS_5_5
    SLASH_5_5 = _coin.SoMarkerSet_SLASH_5_5
    BACKSLASH_5_5 = _coin.SoMarkerSet_BACKSLASH_5_5
    BAR_5_5 = _coin.SoMarkerSet_BAR_5_5
    STAR_5_5 = _coin.SoMarkerSet_STAR_5_5
    Y_5_5 = _coin.SoMarkerSet_Y_5_5
    LIGHTNING_5_5 = _coin.SoMarkerSet_LIGHTNING_5_5
    WELL_5_5 = _coin.SoMarkerSet_WELL_5_5
    CIRCLE_LINE_5_5 = _coin.SoMarkerSet_CIRCLE_LINE_5_5
    SQUARE_LINE_5_5 = _coin.SoMarkerSet_SQUARE_LINE_5_5
    DIAMOND_LINE_5_5 = _coin.SoMarkerSet_DIAMOND_LINE_5_5
    TRIANGLE_LINE_5_5 = _coin.SoMarkerSet_TRIANGLE_LINE_5_5
    RHOMBUS_LINE_5_5 = _coin.SoMarkerSet_RHOMBUS_LINE_5_5
    HOURGLASS_LINE_5_5 = _coin.SoMarkerSet_HOURGLASS_LINE_5_5
    SATELLITE_LINE_5_5 = _coin.SoMarkerSet_SATELLITE_LINE_5_5
    PINE_TREE_LINE_5_5 = _coin.SoMarkerSet_PINE_TREE_LINE_5_5
    CAUTION_LINE_5_5 = _coin.SoMarkerSet_CAUTION_LINE_5_5
    SHIP_LINE_5_5 = _coin.SoMarkerSet_SHIP_LINE_5_5
    CIRCLE_FILLED_5_5 = _coin.SoMarkerSet_CIRCLE_FILLED_5_5
    SQUARE_FILLED_5_5 = _coin.SoMarkerSet_SQUARE_FILLED_5_5
    DIAMOND_FILLED_5_5 = _coin.SoMarkerSet_DIAMOND_FILLED_5_5
    TRIANGLE_FILLED_5_5 = _coin.SoMarkerSet_TRIANGLE_FILLED_5_5
    RHOMBUS_FILLED_5_5 = _coin.SoMarkerSet_RHOMBUS_FILLED_5_5
    HOURGLASS_FILLED_5_5 = _coin.SoMarkerSet_HOURGLASS_FILLED_5_5
    SATELLITE_FILLED_5_5 = _coin.SoMarkerSet_SATELLITE_FILLED_5_5
    PINE_TREE_FILLED_5_5 = _coin.SoMarkerSet_PINE_TREE_FILLED_5_5
    CAUTION_FILLED_5_5 = _coin.SoMarkerSet_CAUTION_FILLED_5_5
    SHIP_FILLED_5_5 = _coin.SoMarkerSet_SHIP_FILLED_5_5
    CROSS_7_7 = _coin.SoMarkerSet_CROSS_7_7
    PLUS_7_7 = _coin.SoMarkerSet_PLUS_7_7
    MINUS_7_7 = _coin.SoMarkerSet_MINUS_7_7
    SLASH_7_7 = _coin.SoMarkerSet_SLASH_7_7
    BACKSLASH_7_7 = _coin.SoMarkerSet_BACKSLASH_7_7
    BAR_7_7 = _coin.SoMarkerSet_BAR_7_7
    STAR_7_7 = _coin.SoMarkerSet_STAR_7_7
    Y_7_7 = _coin.SoMarkerSet_Y_7_7
    LIGHTNING_7_7 = _coin.SoMarkerSet_LIGHTNING_7_7
    WELL_7_7 = _coin.SoMarkerSet_WELL_7_7
    CIRCLE_LINE_7_7 = _coin.SoMarkerSet_CIRCLE_LINE_7_7
    SQUARE_LINE_7_7 = _coin.SoMarkerSet_SQUARE_LINE_7_7
    DIAMOND_LINE_7_7 = _coin.SoMarkerSet_DIAMOND_LINE_7_7
    TRIANGLE_LINE_7_7 = _coin.SoMarkerSet_TRIANGLE_LINE_7_7
    RHOMBUS_LINE_7_7 = _coin.SoMarkerSet_RHOMBUS_LINE_7_7
    HOURGLASS_LINE_7_7 = _coin.SoMarkerSet_HOURGLASS_LINE_7_7
    SATELLITE_LINE_7_7 = _coin.SoMarkerSet_SATELLITE_LINE_7_7
    PINE_TREE_LINE_7_7 = _coin.SoMarkerSet_PINE_TREE_LINE_7_7
    CAUTION_LINE_7_7 = _coin.SoMarkerSet_CAUTION_LINE_7_7
    SHIP_LINE_7_7 = _coin.SoMarkerSet_SHIP_LINE_7_7
    CIRCLE_FILLED_7_7 = _coin.SoMarkerSet_CIRCLE_FILLED_7_7
    SQUARE_FILLED_7_7 = _coin.SoMarkerSet_SQUARE_FILLED_7_7
    DIAMOND_FILLED_7_7 = _coin.SoMarkerSet_DIAMOND_FILLED_7_7
    TRIANGLE_FILLED_7_7 = _coin.SoMarkerSet_TRIANGLE_FILLED_7_7
    RHOMBUS_FILLED_7_7 = _coin.SoMarkerSet_RHOMBUS_FILLED_7_7
    HOURGLASS_FILLED_7_7 = _coin.SoMarkerSet_HOURGLASS_FILLED_7_7
    SATELLITE_FILLED_7_7 = _coin.SoMarkerSet_SATELLITE_FILLED_7_7
    PINE_TREE_FILLED_7_7 = _coin.SoMarkerSet_PINE_TREE_FILLED_7_7
    CAUTION_FILLED_7_7 = _coin.SoMarkerSet_CAUTION_FILLED_7_7
    SHIP_FILLED_7_7 = _coin.SoMarkerSet_SHIP_FILLED_7_7
    CROSS_9_9 = _coin.SoMarkerSet_CROSS_9_9
    PLUS_9_9 = _coin.SoMarkerSet_PLUS_9_9
    MINUS_9_9 = _coin.SoMarkerSet_MINUS_9_9
    SLASH_9_9 = _coin.SoMarkerSet_SLASH_9_9
    BACKSLASH_9_9 = _coin.SoMarkerSet_BACKSLASH_9_9
    BAR_9_9 = _coin.SoMarkerSet_BAR_9_9
    STAR_9_9 = _coin.SoMarkerSet_STAR_9_9
    Y_9_9 = _coin.SoMarkerSet_Y_9_9
    LIGHTNING_9_9 = _coin.SoMarkerSet_LIGHTNING_9_9
    WELL_9_9 = _coin.SoMarkerSet_WELL_9_9
    CIRCLE_LINE_9_9 = _coin.SoMarkerSet_CIRCLE_LINE_9_9
    SQUARE_LINE_9_9 = _coin.SoMarkerSet_SQUARE_LINE_9_9
    DIAMOND_LINE_9_9 = _coin.SoMarkerSet_DIAMOND_LINE_9_9
    TRIANGLE_LINE_9_9 = _coin.SoMarkerSet_TRIANGLE_LINE_9_9
    RHOMBUS_LINE_9_9 = _coin.SoMarkerSet_RHOMBUS_LINE_9_9
    HOURGLASS_LINE_9_9 = _coin.SoMarkerSet_HOURGLASS_LINE_9_9
    SATELLITE_LINE_9_9 = _coin.SoMarkerSet_SATELLITE_LINE_9_9
    PINE_TREE_LINE_9_9 = _coin.SoMarkerSet_PINE_TREE_LINE_9_9
    CAUTION_LINE_9_9 = _coin.SoMarkerSet_CAUTION_LINE_9_9
    SHIP_LINE_9_9 = _coin.SoMarkerSet_SHIP_LINE_9_9
    CIRCLE_FILLED_9_9 = _coin.SoMarkerSet_CIRCLE_FILLED_9_9
    SQUARE_FILLED_9_9 = _coin.SoMarkerSet_SQUARE_FILLED_9_9
    DIAMOND_FILLED_9_9 = _coin.SoMarkerSet_DIAMOND_FILLED_9_9
    TRIANGLE_FILLED_9_9 = _coin.SoMarkerSet_TRIANGLE_FILLED_9_9
    RHOMBUS_FILLED_9_9 = _coin.SoMarkerSet_RHOMBUS_FILLED_9_9
    HOURGLASS_FILLED_9_9 = _coin.SoMarkerSet_HOURGLASS_FILLED_9_9
    SATELLITE_FILLED_9_9 = _coin.SoMarkerSet_SATELLITE_FILLED_9_9
    PINE_TREE_FILLED_9_9 = _coin.SoMarkerSet_PINE_TREE_FILLED_9_9
    CAUTION_FILLED_9_9 = _coin.SoMarkerSet_CAUTION_FILLED_9_9
    SHIP_FILLED_9_9 = _coin.SoMarkerSet_SHIP_FILLED_9_9
    NUM_MARKERS = _coin.SoMarkerSet_NUM_MARKERS
    markerIndex = _swig_property(_coin.SoMarkerSet_markerIndex_get, _coin.SoMarkerSet_markerIndex_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoMarkerSet_GLRender(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoMarkerSet_getPrimitiveCount(self, *args)

    def getNumDefinedMarkers():
        """getNumDefinedMarkers() -> int"""
        return _coin.SoMarkerSet_getNumDefinedMarkers()

    getNumDefinedMarkers = staticmethod(getNumDefinedMarkers)
    def addMarker(*args):
        """
        addMarker(int idx, SbVec2s size, unsigned char bytes, SbBool isLSBFirst = 1, 
            SbBool isUpToDown = 1)
        addMarker(int idx, SbVec2s size, unsigned char bytes, SbBool isLSBFirst = 1)
        addMarker(int idx, SbVec2s size, unsigned char bytes)
        """
        return _coin.SoMarkerSet_addMarker(*args)

    addMarker = staticmethod(addMarker)
    def getMarker(*args):
        """getMarker(int idx, SbVec2s size, unsigned char bytes, SbBool isLSBFirst) -> SbBool"""
        return _coin.SoMarkerSet_getMarker(*args)

    getMarker = staticmethod(getMarker)
    def removeMarker(*args):
        """removeMarker(int idx) -> SbBool"""
        return _coin.SoMarkerSet_removeMarker(*args)

    removeMarker = staticmethod(removeMarker)
    def isMarkerBitSet(*args):
        """isMarkerBitSet(int idx, int bitNumber) -> SbBool"""
        return _coin.SoMarkerSet_isMarkerBitSet(*args)

    isMarkerBitSet = staticmethod(isMarkerBitSet)
SoMarkerSet_swigregister = _coin.SoMarkerSet_swigregister
SoMarkerSet_swigregister(SoMarkerSet)

def SoMarkerSet_getClassTypeId():
  """SoMarkerSet_getClassTypeId() -> SoType"""
  return _coin.SoMarkerSet_getClassTypeId()

def SoMarkerSet_initClass():
  """SoMarkerSet_initClass()"""
  return _coin.SoMarkerSet_initClass()

def SoMarkerSet_getNumDefinedMarkers():
  """SoMarkerSet_getNumDefinedMarkers() -> int"""
  return _coin.SoMarkerSet_getNumDefinedMarkers()

def SoMarkerSet_addMarker(*args):
  """
    addMarker(int idx, SbVec2s size, unsigned char bytes, SbBool isLSBFirst = 1, 
        SbBool isUpToDown = 1)
    addMarker(int idx, SbVec2s size, unsigned char bytes, SbBool isLSBFirst = 1)
    SoMarkerSet_addMarker(int idx, SbVec2s size, unsigned char bytes)
    """
  return _coin.SoMarkerSet_addMarker(*args)

def SoMarkerSet_getMarker(*args):
  """SoMarkerSet_getMarker(int idx, SbVec2s size, unsigned char bytes, SbBool isLSBFirst) -> SbBool"""
  return _coin.SoMarkerSet_getMarker(*args)

def SoMarkerSet_removeMarker(*args):
  """SoMarkerSet_removeMarker(int idx) -> SbBool"""
  return _coin.SoMarkerSet_removeMarker(*args)

def SoMarkerSet_isMarkerBitSet(*args):
  """SoMarkerSet_isMarkerBitSet(int idx, int bitNumber) -> SbBool"""
  return _coin.SoMarkerSet_isMarkerBitSet(*args)

class SoMaterial(SoNode):
    """Proxy of C++ SoMaterial class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMaterial_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMaterial_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoMaterial_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoMaterial"""
        this = _coin.new_SoMaterial()
        try: self.this.append(this)
        except: self.this = this
    ambientColor = _swig_property(_coin.SoMaterial_ambientColor_get, _coin.SoMaterial_ambientColor_set)
    diffuseColor = _swig_property(_coin.SoMaterial_diffuseColor_get, _coin.SoMaterial_diffuseColor_set)
    specularColor = _swig_property(_coin.SoMaterial_specularColor_get, _coin.SoMaterial_specularColor_set)
    emissiveColor = _swig_property(_coin.SoMaterial_emissiveColor_get, _coin.SoMaterial_emissiveColor_set)
    shininess = _swig_property(_coin.SoMaterial_shininess_get, _coin.SoMaterial_shininess_set)
    transparency = _swig_property(_coin.SoMaterial_transparency_get, _coin.SoMaterial_transparency_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoMaterial_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoMaterial_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoMaterial_callback(self, *args)

SoMaterial_swigregister = _coin.SoMaterial_swigregister
SoMaterial_swigregister(SoMaterial)

def SoMaterial_getClassTypeId():
  """SoMaterial_getClassTypeId() -> SoType"""
  return _coin.SoMaterial_getClassTypeId()

def SoMaterial_initClass():
  """SoMaterial_initClass()"""
  return _coin.SoMaterial_initClass()

class SoMatrixTransform(SoTransformation):
    """Proxy of C++ SoMatrixTransform class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMatrixTransform_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMatrixTransform_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoMatrixTransform_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoMatrixTransform"""
        this = _coin.new_SoMatrixTransform()
        try: self.this.append(this)
        except: self.this = this
    matrix = _swig_property(_coin.SoMatrixTransform_matrix_get, _coin.SoMatrixTransform_matrix_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoMatrixTransform_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoMatrixTransform_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoMatrixTransform_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoMatrixTransform_getBoundingBox(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoMatrixTransform_getMatrix(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoMatrixTransform_pick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoMatrixTransform_getPrimitiveCount(self, *args)

SoMatrixTransform_swigregister = _coin.SoMatrixTransform_swigregister
SoMatrixTransform_swigregister(SoMatrixTransform)

def SoMatrixTransform_getClassTypeId():
  """SoMatrixTransform_getClassTypeId() -> SoType"""
  return _coin.SoMatrixTransform_getClassTypeId()

def SoMatrixTransform_initClass():
  """SoMatrixTransform_initClass()"""
  return _coin.SoMatrixTransform_initClass()

class SoMultipleCopy(SoGroup):
    """Proxy of C++ SoMultipleCopy class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoMultipleCopy_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoMultipleCopy_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoMultipleCopy_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoMultipleCopy"""
        this = _coin.new_SoMultipleCopy()
        try: self.this.append(this)
        except: self.this = this
    matrix = _swig_property(_coin.SoMultipleCopy_matrix_get, _coin.SoMultipleCopy_matrix_set)
    def affectsState(self):
        """affectsState(self) -> SbBool"""
        return _coin.SoMultipleCopy_affectsState(self)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoMultipleCopy_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoMultipleCopy_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoMultipleCopy_GLRender(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoMultipleCopy_pick(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoMultipleCopy_getBoundingBox(self, *args)

    def handleEvent(self, *args):
        """handleEvent(self, SoHandleEventAction action)"""
        return _coin.SoMultipleCopy_handleEvent(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoMultipleCopy_getMatrix(self, *args)

    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoMultipleCopy_search(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoMultipleCopy_getPrimitiveCount(self, *args)

    def audioRender(self, *args):
        """audioRender(self, SoAudioRenderAction action)"""
        return _coin.SoMultipleCopy_audioRender(self, *args)

SoMultipleCopy_swigregister = _coin.SoMultipleCopy_swigregister
SoMultipleCopy_swigregister(SoMultipleCopy)

def SoMultipleCopy_getClassTypeId():
  """SoMultipleCopy_getClassTypeId() -> SoType"""
  return _coin.SoMultipleCopy_getClassTypeId()

def SoMultipleCopy_initClass():
  """SoMultipleCopy_initClass()"""
  return _coin.SoMultipleCopy_initClass()

class SoPerspectiveCamera(SoCamera):
    """Proxy of C++ SoPerspectiveCamera class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoPerspectiveCamera_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoPerspectiveCamera_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoPerspectiveCamera_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoPerspectiveCamera"""
        this = _coin.new_SoPerspectiveCamera()
        try: self.this.append(this)
        except: self.this = this
    heightAngle = _swig_property(_coin.SoPerspectiveCamera_heightAngle_get, _coin.SoPerspectiveCamera_heightAngle_set)
    def scaleHeight(self, *args):
        """scaleHeight(self, float scalefactor)"""
        return _coin.SoPerspectiveCamera_scaleHeight(self, *args)

    def getViewVolume(self, useaspectratio = 0.0):
        """
        getViewVolume(self, float useaspectratio = 0.0) -> SbViewVolume
        getViewVolume(self) -> SbViewVolume
        """
        return _coin.SoPerspectiveCamera_getViewVolume(self, useaspectratio)

SoPerspectiveCamera_swigregister = _coin.SoPerspectiveCamera_swigregister
SoPerspectiveCamera_swigregister(SoPerspectiveCamera)

def SoPerspectiveCamera_getClassTypeId():
  """SoPerspectiveCamera_getClassTypeId() -> SoType"""
  return _coin.SoPerspectiveCamera_getClassTypeId()

def SoPerspectiveCamera_initClass():
  """SoPerspectiveCamera_initClass()"""
  return _coin.SoPerspectiveCamera_initClass()

class SoOrthographicCamera(SoCamera):
    """Proxy of C++ SoOrthographicCamera class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoOrthographicCamera_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoOrthographicCamera_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoOrthographicCamera_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoOrthographicCamera"""
        this = _coin.new_SoOrthographicCamera()
        try: self.this.append(this)
        except: self.this = this
    height = _swig_property(_coin.SoOrthographicCamera_height_get, _coin.SoOrthographicCamera_height_set)
    def scaleHeight(self, *args):
        """scaleHeight(self, float scalefactor)"""
        return _coin.SoOrthographicCamera_scaleHeight(self, *args)

    def getViewVolume(self, useaspectratio = 0.0):
        """
        getViewVolume(self, float useaspectratio = 0.0) -> SbViewVolume
        getViewVolume(self) -> SbViewVolume
        """
        return _coin.SoOrthographicCamera_getViewVolume(self, useaspectratio)

SoOrthographicCamera_swigregister = _coin.SoOrthographicCamera_swigregister
SoOrthographicCamera_swigregister(SoOrthographicCamera)

def SoOrthographicCamera_getClassTypeId():
  """SoOrthographicCamera_getClassTypeId() -> SoType"""
  return _coin.SoOrthographicCamera_getClassTypeId()

def SoOrthographicCamera_initClass():
  """SoOrthographicCamera_initClass()"""
  return _coin.SoOrthographicCamera_initClass()

class SoFrustumCamera(SoCamera):
    """Proxy of C++ SoFrustumCamera class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoFrustumCamera_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoFrustumCamera_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoFrustumCamera_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoFrustumCamera"""
        this = _coin.new_SoFrustumCamera()
        try: self.this.append(this)
        except: self.this = this
    left = _swig_property(_coin.SoFrustumCamera_left_get, _coin.SoFrustumCamera_left_set)
    right = _swig_property(_coin.SoFrustumCamera_right_get, _coin.SoFrustumCamera_right_set)
    top = _swig_property(_coin.SoFrustumCamera_top_get, _coin.SoFrustumCamera_top_set)
    bottom = _swig_property(_coin.SoFrustumCamera_bottom_get, _coin.SoFrustumCamera_bottom_set)
    def scaleHeight(self, *args):
        """scaleHeight(self, float scalefactor)"""
        return _coin.SoFrustumCamera_scaleHeight(self, *args)

    def getViewVolume(self, useaspectratio = 0.0):
        """
        getViewVolume(self, float useaspectratio = 0.0) -> SbViewVolume
        getViewVolume(self) -> SbViewVolume
        """
        return _coin.SoFrustumCamera_getViewVolume(self, useaspectratio)

SoFrustumCamera_swigregister = _coin.SoFrustumCamera_swigregister
SoFrustumCamera_swigregister(SoFrustumCamera)

def SoFrustumCamera_getClassTypeId():
  """SoFrustumCamera_getClassTypeId() -> SoType"""
  return _coin.SoFrustumCamera_getClassTypeId()

def SoFrustumCamera_initClass():
  """SoFrustumCamera_initClass()"""
  return _coin.SoFrustumCamera_initClass()

class SoQuadMesh(SoNonIndexedShape):
    """Proxy of C++ SoQuadMesh class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoQuadMesh_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoQuadMesh_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoQuadMesh_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoQuadMesh"""
        this = _coin.new_SoQuadMesh()
        try: self.this.append(this)
        except: self.this = this
    verticesPerColumn = _swig_property(_coin.SoQuadMesh_verticesPerColumn_get, _coin.SoQuadMesh_verticesPerColumn_set)
    verticesPerRow = _swig_property(_coin.SoQuadMesh_verticesPerRow_get, _coin.SoQuadMesh_verticesPerRow_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoQuadMesh_GLRender(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoQuadMesh_getPrimitiveCount(self, *args)

    def generateDefaultNormals(self, *args):
        """generateDefaultNormals(self, SoState state, SoNormalBundle nb) -> SbBool"""
        return _coin.SoQuadMesh_generateDefaultNormals(self, *args)

SoQuadMesh_swigregister = _coin.SoQuadMesh_swigregister
SoQuadMesh_swigregister(SoQuadMesh)

def SoQuadMesh_getClassTypeId():
  """SoQuadMesh_getClassTypeId() -> SoType"""
  return _coin.SoQuadMesh_getClassTypeId()

def SoQuadMesh_initClass():
  """SoQuadMesh_initClass()"""
  return _coin.SoQuadMesh_initClass()

class SoTriangleStripSet(SoNonIndexedShape):
    """Proxy of C++ SoTriangleStripSet class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTriangleStripSet_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTriangleStripSet_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTriangleStripSet_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTriangleStripSet"""
        this = _coin.new_SoTriangleStripSet()
        try: self.this.append(this)
        except: self.this = this
    numVertices = _swig_property(_coin.SoTriangleStripSet_numVertices_get, _coin.SoTriangleStripSet_numVertices_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoTriangleStripSet_GLRender(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoTriangleStripSet_getPrimitiveCount(self, *args)

    def generateDefaultNormals(self, *args):
        """generateDefaultNormals(self, SoState state, SoNormalBundle nb) -> SbBool"""
        return _coin.SoTriangleStripSet_generateDefaultNormals(self, *args)

SoTriangleStripSet_swigregister = _coin.SoTriangleStripSet_swigregister
SoTriangleStripSet_swigregister(SoTriangleStripSet)

def SoTriangleStripSet_getClassTypeId():
  """SoTriangleStripSet_getClassTypeId() -> SoType"""
  return _coin.SoTriangleStripSet_getClassTypeId()

def SoTriangleStripSet_initClass():
  """SoTriangleStripSet_initClass()"""
  return _coin.SoTriangleStripSet_initClass()

class SoIndexedPointSet(SoIndexedShape):
    """Proxy of C++ SoIndexedPointSet class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoIndexedPointSet_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoIndexedPointSet_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoIndexedPointSet_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoIndexedPointSet"""
        this = _coin.new_SoIndexedPointSet()
        try: self.this.append(this)
        except: self.this = this
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoIndexedPointSet_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoIndexedPointSet_getBoundingBox(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoIndexedPointSet_getPrimitiveCount(self, *args)

    def notify(self, *args):
        """notify(self, SoNotList list)"""
        return _coin.SoIndexedPointSet_notify(self, *args)

SoIndexedPointSet_swigregister = _coin.SoIndexedPointSet_swigregister
SoIndexedPointSet_swigregister(SoIndexedPointSet)

def SoIndexedPointSet_getClassTypeId():
  """SoIndexedPointSet_getClassTypeId() -> SoType"""
  return _coin.SoIndexedPointSet_getClassTypeId()

def SoIndexedPointSet_initClass():
  """SoIndexedPointSet_initClass()"""
  return _coin.SoIndexedPointSet_initClass()

class SoIndexedMarkerSet(SoIndexedPointSet):
    """Proxy of C++ SoIndexedMarkerSet class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoIndexedMarkerSet_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoIndexedMarkerSet_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoIndexedMarkerSet_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoIndexedMarkerSet"""
        this = _coin.new_SoIndexedMarkerSet()
        try: self.this.append(this)
        except: self.this = this
    markerIndex = _swig_property(_coin.SoIndexedMarkerSet_markerIndex_get, _coin.SoIndexedMarkerSet_markerIndex_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoIndexedMarkerSet_GLRender(self, *args)

    def notify(self, *args):
        """notify(self, SoNotList list)"""
        return _coin.SoIndexedMarkerSet_notify(self, *args)

SoIndexedMarkerSet_swigregister = _coin.SoIndexedMarkerSet_swigregister
SoIndexedMarkerSet_swigregister(SoIndexedMarkerSet)

def SoIndexedMarkerSet_getClassTypeId():
  """SoIndexedMarkerSet_getClassTypeId() -> SoType"""
  return _coin.SoIndexedMarkerSet_getClassTypeId()

def SoIndexedMarkerSet_initClass():
  """SoIndexedMarkerSet_initClass()"""
  return _coin.SoIndexedMarkerSet_initClass()

class SoNurbsCurve(SoShape):
    """Proxy of C++ SoNurbsCurve class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoNurbsCurve_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoNurbsCurve_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoNurbsCurve_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoNurbsCurve"""
        this = _coin.new_SoNurbsCurve()
        try: self.this.append(this)
        except: self.this = this
    numControlPoints = _swig_property(_coin.SoNurbsCurve_numControlPoints_get, _coin.SoNurbsCurve_numControlPoints_set)
    knotVector = _swig_property(_coin.SoNurbsCurve_knotVector_get, _coin.SoNurbsCurve_knotVector_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoNurbsCurve_GLRender(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoNurbsCurve_rayPick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoNurbsCurve_getPrimitiveCount(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoNurbsCurve_getBoundingBox(self, *args)

    def sendPrimitive(self, *args):
        """sendPrimitive(self, SoAction arg0, SoPrimitiveVertex arg1)"""
        return _coin.SoNurbsCurve_sendPrimitive(self, *args)

SoNurbsCurve_swigregister = _coin.SoNurbsCurve_swigregister
SoNurbsCurve_swigregister(SoNurbsCurve)

def SoNurbsCurve_getClassTypeId():
  """SoNurbsCurve_getClassTypeId() -> SoType"""
  return _coin.SoNurbsCurve_getClassTypeId()

def SoNurbsCurve_initClass():
  """SoNurbsCurve_initClass()"""
  return _coin.SoNurbsCurve_initClass()

class SoNurbsSurface(SoShape):
    """Proxy of C++ SoNurbsSurface class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoNurbsSurface_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoNurbsSurface_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoNurbsSurface_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoNurbsSurface"""
        this = _coin.new_SoNurbsSurface()
        try: self.this.append(this)
        except: self.this = this
    numUControlPoints = _swig_property(_coin.SoNurbsSurface_numUControlPoints_get, _coin.SoNurbsSurface_numUControlPoints_set)
    numVControlPoints = _swig_property(_coin.SoNurbsSurface_numVControlPoints_get, _coin.SoNurbsSurface_numVControlPoints_set)
    numSControlPoints = _swig_property(_coin.SoNurbsSurface_numSControlPoints_get, _coin.SoNurbsSurface_numSControlPoints_set)
    numTControlPoints = _swig_property(_coin.SoNurbsSurface_numTControlPoints_get, _coin.SoNurbsSurface_numTControlPoints_set)
    uKnotVector = _swig_property(_coin.SoNurbsSurface_uKnotVector_get, _coin.SoNurbsSurface_uKnotVector_set)
    vKnotVector = _swig_property(_coin.SoNurbsSurface_vKnotVector_get, _coin.SoNurbsSurface_vKnotVector_set)
    sKnotVector = _swig_property(_coin.SoNurbsSurface_sKnotVector_get, _coin.SoNurbsSurface_sKnotVector_set)
    tKnotVector = _swig_property(_coin.SoNurbsSurface_tKnotVector_get, _coin.SoNurbsSurface_tKnotVector_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoNurbsSurface_GLRender(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoNurbsSurface_rayPick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoNurbsSurface_getPrimitiveCount(self, *args)

    def sendPrimitive(self, *args):
        """sendPrimitive(self, SoAction arg0, SoPrimitiveVertex arg1)"""
        return _coin.SoNurbsSurface_sendPrimitive(self, *args)

SoNurbsSurface_swigregister = _coin.SoNurbsSurface_swigregister
SoNurbsSurface_swigregister(SoNurbsSurface)

def SoNurbsSurface_getClassTypeId():
  """SoNurbsSurface_getClassTypeId() -> SoType"""
  return _coin.SoNurbsSurface_getClassTypeId()

def SoNurbsSurface_initClass():
  """SoNurbsSurface_initClass()"""
  return _coin.SoNurbsSurface_initClass()

class SoSphere(SoShape):
    """Proxy of C++ SoSphere class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSphere_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSphere_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoSphere_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoSphere"""
        this = _coin.new_SoSphere()
        try: self.this.append(this)
        except: self.this = this
    radius = _swig_property(_coin.SoSphere_radius_get, _coin.SoSphere_radius_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoSphere_GLRender(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoSphere_rayPick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoSphere_getPrimitiveCount(self, *args)

SoSphere_swigregister = _coin.SoSphere_swigregister
SoSphere_swigregister(SoSphere)

def SoSphere_getClassTypeId():
  """SoSphere_getClassTypeId() -> SoType"""
  return _coin.SoSphere_getClassTypeId()

def SoSphere_initClass():
  """SoSphere_initClass()"""
  return _coin.SoSphere_initClass()

class SoText2(SoShape):
    """Proxy of C++ SoText2 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoText2_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoText2_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoText2_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoText2"""
        this = _coin.new_SoText2()
        try: self.this.append(this)
        except: self.this = this
    LEFT = _coin.SoText2_LEFT
    RIGHT = _coin.SoText2_RIGHT
    CENTER = _coin.SoText2_CENTER
    string = _swig_property(_coin.SoText2_string_get, _coin.SoText2_string_set)
    spacing = _swig_property(_coin.SoText2_spacing_get, _coin.SoText2_spacing_set)
    justification = _swig_property(_coin.SoText2_justification_get, _coin.SoText2_justification_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoText2_GLRender(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoText2_rayPick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoText2_getPrimitiveCount(self, *args)

SoText2_swigregister = _coin.SoText2_swigregister
SoText2_swigregister(SoText2)

def SoText2_getClassTypeId():
  """SoText2_getClassTypeId() -> SoType"""
  return _coin.SoText2_getClassTypeId()

def SoText2_initClass():
  """SoText2_initClass()"""
  return _coin.SoText2_initClass()

class SoText3(SoShape):
    """Proxy of C++ SoText3 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoText3_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoText3_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoText3_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoText3"""
        this = _coin.new_SoText3()
        try: self.this.append(this)
        except: self.this = this
    FRONT = _coin.SoText3_FRONT
    SIDES = _coin.SoText3_SIDES
    BACK = _coin.SoText3_BACK
    ALL = _coin.SoText3_ALL
    LEFT = _coin.SoText3_LEFT
    RIGHT = _coin.SoText3_RIGHT
    CENTER = _coin.SoText3_CENTER
    string = _swig_property(_coin.SoText3_string_get, _coin.SoText3_string_set)
    spacing = _swig_property(_coin.SoText3_spacing_get, _coin.SoText3_spacing_set)
    justification = _swig_property(_coin.SoText3_justification_get, _coin.SoText3_justification_set)
    parts = _swig_property(_coin.SoText3_parts_get, _coin.SoText3_parts_set)
    def getCharacterBounds(self, *args):
        """getCharacterBounds(self, SoState state, int stringindex, int charindex) -> SbBox3f"""
        return _coin.SoText3_getCharacterBounds(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoText3_GLRender(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoText3_getPrimitiveCount(self, *args)

SoText3_swigregister = _coin.SoText3_swigregister
SoText3_swigregister(SoText3)

def SoText3_getClassTypeId():
  """SoText3_getClassTypeId() -> SoType"""
  return _coin.SoText3_getClassTypeId()

def SoText3_initClass():
  """SoText3_initClass()"""
  return _coin.SoText3_initClass()

class SoWWWAnchor(SoLocateHighlight):
    """Proxy of C++ SoWWWAnchor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoWWWAnchor_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoWWWAnchor_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoWWWAnchor_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoWWWAnchor"""
        this = _coin.new_SoWWWAnchor()
        try: self.this.append(this)
        except: self.this = this
    NONE = _coin.SoWWWAnchor_NONE
    POINT = _coin.SoWWWAnchor_POINT
    name = _swig_property(_coin.SoWWWAnchor_name_get, _coin.SoWWWAnchor_name_set)
    description = _swig_property(_coin.SoWWWAnchor_description_get, _coin.SoWWWAnchor_description_set)
    map = _swig_property(_coin.SoWWWAnchor_map_get, _coin.SoWWWAnchor_map_set)
    def setFullURLName(self, *args):
        """setFullURLName(self, SbString url)"""
        return _coin.SoWWWAnchor_setFullURLName(self, *args)

    def getFullURLName(self):
        """getFullURLName(self) -> SbString"""
        return _coin.SoWWWAnchor_getFullURLName(self)

    def handleEvent(self, *args):
        """handleEvent(self, SoHandleEventAction action)"""
        return _coin.SoWWWAnchor_handleEvent(self, *args)

    def setFetchURLCallBack(*args):
        """setFetchURLCallBack(SoWWWAnchorCB f, void userData)"""
        return _coin.SoWWWAnchor_setFetchURLCallBack(*args)

    setFetchURLCallBack = staticmethod(setFetchURLCallBack)
    def setHighlightURLCallBack(*args):
        """setHighlightURLCallBack(SoWWWAnchorCB f, void userData)"""
        return _coin.SoWWWAnchor_setHighlightURLCallBack(*args)

    setHighlightURLCallBack = staticmethod(setHighlightURLCallBack)
SoWWWAnchor_swigregister = _coin.SoWWWAnchor_swigregister
SoWWWAnchor_swigregister(SoWWWAnchor)

def SoWWWAnchor_getClassTypeId():
  """SoWWWAnchor_getClassTypeId() -> SoType"""
  return _coin.SoWWWAnchor_getClassTypeId()

def SoWWWAnchor_initClass():
  """SoWWWAnchor_initClass()"""
  return _coin.SoWWWAnchor_initClass()

def SoWWWAnchor_setFetchURLCallBack(*args):
  """SoWWWAnchor_setFetchURLCallBack(SoWWWAnchorCB f, void userData)"""
  return _coin.SoWWWAnchor_setFetchURLCallBack(*args)

def SoWWWAnchor_setHighlightURLCallBack(*args):
  """SoWWWAnchor_setHighlightURLCallBack(SoWWWAnchorCB f, void userData)"""
  return _coin.SoWWWAnchor_setHighlightURLCallBack(*args)

class SoPathSwitch(SoGroup):
    """Proxy of C++ SoPathSwitch class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoPathSwitch_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoPathSwitch_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoPathSwitch_initClass()

    initClass = staticmethod(initClass)
    def __init__(self, *args): 
        """
        __init__(self) -> SoPathSwitch
        __init__(self, int numchildren) -> SoPathSwitch
        """
        this = _coin.new_SoPathSwitch(*args)
        try: self.this.append(this)
        except: self.this = this
    path = _swig_property(_coin.SoPathSwitch_path_get, _coin.SoPathSwitch_path_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoPathSwitch_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoPathSwitch_GLRender(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoPathSwitch_pick(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoPathSwitch_getBoundingBox(self, *args)

    def handleEvent(self, *args):
        """handleEvent(self, SoHandleEventAction action)"""
        return _coin.SoPathSwitch_handleEvent(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoPathSwitch_getMatrix(self, *args)

    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoPathSwitch_search(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoPathSwitch_callback(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoPathSwitch_getPrimitiveCount(self, *args)

    def audioRender(self, *args):
        """audioRender(self, SoAudioRenderAction action)"""
        return _coin.SoPathSwitch_audioRender(self, *args)

SoPathSwitch_swigregister = _coin.SoPathSwitch_swigregister
SoPathSwitch_swigregister(SoPathSwitch)

def SoPathSwitch_getClassTypeId():
  """SoPathSwitch_getClassTypeId() -> SoType"""
  return _coin.SoPathSwitch_getClassTypeId()

def SoPathSwitch_initClass():
  """SoPathSwitch_initClass()"""
  return _coin.SoPathSwitch_initClass()

class SoTransformSeparator(SoGroup):
    """Proxy of C++ SoTransformSeparator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTransformSeparator_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTransformSeparator_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTransformSeparator_initClass()

    initClass = staticmethod(initClass)
    def __init__(self, *args): 
        """
        __init__(self) -> SoTransformSeparator
        __init__(self, int nChildren) -> SoTransformSeparator
        """
        this = _coin.new_SoTransformSeparator(*args)
        try: self.this.append(this)
        except: self.this = this
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoTransformSeparator_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoTransformSeparator_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoTransformSeparator_GLRender(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoTransformSeparator_pick(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoTransformSeparator_getBoundingBox(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoTransformSeparator_getMatrix(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoTransformSeparator_getPrimitiveCount(self, *args)

    def audioRender(self, *args):
        """audioRender(self, SoAudioRenderAction action)"""
        return _coin.SoTransformSeparator_audioRender(self, *args)

SoTransformSeparator_swigregister = _coin.SoTransformSeparator_swigregister
SoTransformSeparator_swigregister(SoTransformSeparator)

def SoTransformSeparator_getClassTypeId():
  """SoTransformSeparator_getClassTypeId() -> SoType"""
  return _coin.SoTransformSeparator_getClassTypeId()

def SoTransformSeparator_initClass():
  """SoTransformSeparator_initClass()"""
  return _coin.SoTransformSeparator_initClass()

class SoRotation(SoTransformation):
    """Proxy of C++ SoRotation class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoRotation_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoRotation_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoRotation_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoRotation"""
        this = _coin.new_SoRotation()
        try: self.this.append(this)
        except: self.this = this
    rotation = _swig_property(_coin.SoRotation_rotation_get, _coin.SoRotation_rotation_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoRotation_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoRotation_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoRotation_callback(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoRotation_getBoundingBox(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoRotation_getMatrix(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoRotation_pick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoRotation_getPrimitiveCount(self, *args)

SoRotation_swigregister = _coin.SoRotation_swigregister
SoRotation_swigregister(SoRotation)

def SoRotation_getClassTypeId():
  """SoRotation_getClassTypeId() -> SoType"""
  return _coin.SoRotation_getClassTypeId()

def SoRotation_initClass():
  """SoRotation_initClass()"""
  return _coin.SoRotation_initClass()

class SoPendulum(SoRotation):
    """Proxy of C++ SoPendulum class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoPendulum_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoPendulum_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoPendulum_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoPendulum"""
        this = _coin.new_SoPendulum()
        try: self.this.append(this)
        except: self.this = this
    rotation0 = _swig_property(_coin.SoPendulum_rotation0_get, _coin.SoPendulum_rotation0_set)
    rotation1 = _swig_property(_coin.SoPendulum_rotation1_get, _coin.SoPendulum_rotation1_set)
    speed = _swig_property(_coin.SoPendulum_speed_get, _coin.SoPendulum_speed_set)
    on = _swig_property(_coin.SoPendulum_on_get, _coin.SoPendulum_on_set)
    def write(self, *args):
        """write(self, SoWriteAction action)"""
        return _coin.SoPendulum_write(self, *args)

SoPendulum_swigregister = _coin.SoPendulum_swigregister
SoPendulum_swigregister(SoPendulum)

def SoPendulum_getClassTypeId():
  """SoPendulum_getClassTypeId() -> SoType"""
  return _coin.SoPendulum_getClassTypeId()

def SoPendulum_initClass():
  """SoPendulum_initClass()"""
  return _coin.SoPendulum_initClass()

class SoRotor(SoRotation):
    """Proxy of C++ SoRotor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoRotor_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoRotor_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoRotor_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoRotor"""
        this = _coin.new_SoRotor()
        try: self.this.append(this)
        except: self.this = this
    speed = _swig_property(_coin.SoRotor_speed_get, _coin.SoRotor_speed_set)
    on = _swig_property(_coin.SoRotor_on_get, _coin.SoRotor_on_set)
SoRotor_swigregister = _coin.SoRotor_swigregister
SoRotor_swigregister(SoRotor)

def SoRotor_getClassTypeId():
  """SoRotor_getClassTypeId() -> SoType"""
  return _coin.SoRotor_getClassTypeId()

def SoRotor_initClass():
  """SoRotor_initClass()"""
  return _coin.SoRotor_initClass()

class SoResetTransform(SoTransformation):
    """Proxy of C++ SoResetTransform class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoResetTransform_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoResetTransform_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoResetTransform_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoResetTransform"""
        this = _coin.new_SoResetTransform()
        try: self.this.append(this)
        except: self.this = this
    TRANSFORM = _coin.SoResetTransform_TRANSFORM
    BBOX = _coin.SoResetTransform_BBOX
    whatToReset = _swig_property(_coin.SoResetTransform_whatToReset_get, _coin.SoResetTransform_whatToReset_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoResetTransform_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoResetTransform_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoResetTransform_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoResetTransform_getBoundingBox(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoResetTransform_getMatrix(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoResetTransform_pick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoResetTransform_getPrimitiveCount(self, *args)

SoResetTransform_swigregister = _coin.SoResetTransform_swigregister
SoResetTransform_swigregister(SoResetTransform)

def SoResetTransform_getClassTypeId():
  """SoResetTransform_getClassTypeId() -> SoType"""
  return _coin.SoResetTransform_getClassTypeId()

def SoResetTransform_initClass():
  """SoResetTransform_initClass()"""
  return _coin.SoResetTransform_initClass()

class SoRotationXYZ(SoTransformation):
    """Proxy of C++ SoRotationXYZ class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoRotationXYZ_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoRotationXYZ_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoRotationXYZ_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoRotationXYZ"""
        this = _coin.new_SoRotationXYZ()
        try: self.this.append(this)
        except: self.this = this
    X = _coin.SoRotationXYZ_X
    Y = _coin.SoRotationXYZ_Y
    Z = _coin.SoRotationXYZ_Z
    axis = _swig_property(_coin.SoRotationXYZ_axis_get, _coin.SoRotationXYZ_axis_set)
    angle = _swig_property(_coin.SoRotationXYZ_angle_get, _coin.SoRotationXYZ_angle_set)
    def getRotation(self):
        """getRotation(self) -> SbRotation"""
        return _coin.SoRotationXYZ_getRotation(self)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoRotationXYZ_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoRotationXYZ_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoRotationXYZ_callback(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoRotationXYZ_getBoundingBox(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoRotationXYZ_getMatrix(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoRotationXYZ_pick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoRotationXYZ_getPrimitiveCount(self, *args)

SoRotationXYZ_swigregister = _coin.SoRotationXYZ_swigregister
SoRotationXYZ_swigregister(SoRotationXYZ)

def SoRotationXYZ_getClassTypeId():
  """SoRotationXYZ_getClassTypeId() -> SoType"""
  return _coin.SoRotationXYZ_getClassTypeId()

def SoRotationXYZ_initClass():
  """SoRotationXYZ_initClass()"""
  return _coin.SoRotationXYZ_initClass()

class SoTranslation(SoTransformation):
    """Proxy of C++ SoTranslation class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTranslation_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTranslation_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTranslation_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTranslation"""
        this = _coin.new_SoTranslation()
        try: self.this.append(this)
        except: self.this = this
    translation = _swig_property(_coin.SoTranslation_translation_get, _coin.SoTranslation_translation_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoTranslation_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoTranslation_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoTranslation_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoTranslation_getBoundingBox(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoTranslation_getMatrix(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoTranslation_pick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoTranslation_getPrimitiveCount(self, *args)

SoTranslation_swigregister = _coin.SoTranslation_swigregister
SoTranslation_swigregister(SoTranslation)

def SoTranslation_getClassTypeId():
  """SoTranslation_getClassTypeId() -> SoType"""
  return _coin.SoTranslation_getClassTypeId()

def SoTranslation_initClass():
  """SoTranslation_initClass()"""
  return _coin.SoTranslation_initClass()

class SoShuttle(SoTranslation):
    """Proxy of C++ SoShuttle class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShuttle_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoShuttle_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoShuttle_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoShuttle"""
        this = _coin.new_SoShuttle()
        try: self.this.append(this)
        except: self.this = this
    translation0 = _swig_property(_coin.SoShuttle_translation0_get, _coin.SoShuttle_translation0_set)
    translation1 = _swig_property(_coin.SoShuttle_translation1_get, _coin.SoShuttle_translation1_set)
    speed = _swig_property(_coin.SoShuttle_speed_get, _coin.SoShuttle_speed_set)
    on = _swig_property(_coin.SoShuttle_on_get, _coin.SoShuttle_on_set)
    def write(self, *args):
        """write(self, SoWriteAction action)"""
        return _coin.SoShuttle_write(self, *args)

SoShuttle_swigregister = _coin.SoShuttle_swigregister
SoShuttle_swigregister(SoShuttle)

def SoShuttle_getClassTypeId():
  """SoShuttle_getClassTypeId() -> SoType"""
  return _coin.SoShuttle_getClassTypeId()

def SoShuttle_initClass():
  """SoShuttle_initClass()"""
  return _coin.SoShuttle_initClass()

class SoSurroundScale(SoTransformation):
    """Proxy of C++ SoSurroundScale class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSurroundScale_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSurroundScale_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoSurroundScale_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoSurroundScale"""
        this = _coin.new_SoSurroundScale()
        try: self.this.append(this)
        except: self.this = this
    numNodesUpToContainer = _swig_property(_coin.SoSurroundScale_numNodesUpToContainer_get, _coin.SoSurroundScale_numNodesUpToContainer_set)
    numNodesUpToReset = _swig_property(_coin.SoSurroundScale_numNodesUpToReset_get, _coin.SoSurroundScale_numNodesUpToReset_set)
    def invalidate(self):
        """invalidate(self)"""
        return _coin.SoSurroundScale_invalidate(self)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoSurroundScale_doAction(self, *args)

    def setDoingTranslations(self, *args):
        """setDoingTranslations(self, SbBool val)"""
        return _coin.SoSurroundScale_setDoingTranslations(self, *args)

    def isDoingTranslations(self):
        """isDoingTranslations(self) -> SbBool"""
        return _coin.SoSurroundScale_isDoingTranslations(self)

SoSurroundScale_swigregister = _coin.SoSurroundScale_swigregister
SoSurroundScale_swigregister(SoSurroundScale)

def SoSurroundScale_getClassTypeId():
  """SoSurroundScale_getClassTypeId() -> SoType"""
  return _coin.SoSurroundScale_getClassTypeId()

def SoSurroundScale_initClass():
  """SoSurroundScale_initClass()"""
  return _coin.SoSurroundScale_initClass()

class SoNurbsProfile(SoProfile):
    """Proxy of C++ SoNurbsProfile class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoNurbsProfile_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoNurbsProfile_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoNurbsProfile_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoNurbsProfile"""
        this = _coin.new_SoNurbsProfile()
        try: self.this.append(this)
        except: self.this = this
    knotVector = _swig_property(_coin.SoNurbsProfile_knotVector_get, _coin.SoNurbsProfile_knotVector_set)
    def getTrimCurve(self, *args):
        """
        getTrimCurve(self, SoState state, int32_t numpoints, float points, int floatspervec, 
            int32_t numknots, float knotvector)
        """
        return _coin.SoNurbsProfile_getTrimCurve(self, *args)

    def getVertices(self, *args):
        """getVertices(self, SoState state, int32_t numvertices, SbVec2f vertices)"""
        return _coin.SoNurbsProfile_getVertices(self, *args)

SoNurbsProfile_swigregister = _coin.SoNurbsProfile_swigregister
SoNurbsProfile_swigregister(SoNurbsProfile)

def SoNurbsProfile_getClassTypeId():
  """SoNurbsProfile_getClassTypeId() -> SoType"""
  return _coin.SoNurbsProfile_getClassTypeId()

def SoNurbsProfile_initClass():
  """SoNurbsProfile_initClass()"""
  return _coin.SoNurbsProfile_initClass()

class SoVertexAttribute(SoNode):
    """Proxy of C++ SoVertexAttribute class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoVertexAttribute"""
        this = _coin.new_SoVertexAttribute()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoVertexAttribute_initClass()

    initClass = staticmethod(initClass)
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVertexAttribute_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVertexAttribute_getTypeId(self)

    name = _swig_property(_coin.SoVertexAttribute_name_get, _coin.SoVertexAttribute_name_set)
    typeName = _swig_property(_coin.SoVertexAttribute_typeName_get, _coin.SoVertexAttribute_typeName_set)
    def getValuesField(self):
        """getValuesField(self) -> SoMField"""
        return _coin.SoVertexAttribute_getValuesField(self)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoVertexAttribute_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVertexAttribute_GLRender(self, *args)

    def write(self, *args):
        """write(self, SoWriteAction action)"""
        return _coin.SoVertexAttribute_write(self, *args)

    def copyContents(self, *args):
        """copyContents(self, SoFieldContainer srcFrom, SbBool copyconnections)"""
        return _coin.SoVertexAttribute_copyContents(self, *args)

    def notify(self, *args):
        """notify(self, SoNotList l)"""
        return _coin.SoVertexAttribute_notify(self, *args)

SoVertexAttribute_swigregister = _coin.SoVertexAttribute_swigregister
SoVertexAttribute_swigregister(SoVertexAttribute)

def SoVertexAttribute_initClass():
  """SoVertexAttribute_initClass()"""
  return _coin.SoVertexAttribute_initClass()

def SoVertexAttribute_getClassTypeId():
  """SoVertexAttribute_getClassTypeId() -> SoType"""
  return _coin.SoVertexAttribute_getClassTypeId()

class SoVertexAttributeBinding(SoNode):
    """Proxy of C++ SoVertexAttributeBinding class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVertexAttributeBinding_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVertexAttributeBinding_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVertexAttributeBinding_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVertexAttributeBinding"""
        this = _coin.new_SoVertexAttributeBinding()
        try: self.this.append(this)
        except: self.this = this
    OVERALL = _coin.SoVertexAttributeBinding_OVERALL
    PER_VERTEX = _coin.SoVertexAttributeBinding_PER_VERTEX
    PER_VERTEX_INDEXED = _coin.SoVertexAttributeBinding_PER_VERTEX_INDEXED
    DEFAULT = _coin.SoVertexAttributeBinding_DEFAULT
    value = _swig_property(_coin.SoVertexAttributeBinding_value_get, _coin.SoVertexAttributeBinding_value_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoVertexAttributeBinding_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVertexAttributeBinding_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoVertexAttributeBinding_callback(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoVertexAttributeBinding_pick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVertexAttributeBinding_getPrimitiveCount(self, *args)

SoVertexAttributeBinding_swigregister = _coin.SoVertexAttributeBinding_swigregister
SoVertexAttributeBinding_swigregister(SoVertexAttributeBinding)

def SoVertexAttributeBinding_getClassTypeId():
  """SoVertexAttributeBinding_getClassTypeId() -> SoType"""
  return _coin.SoVertexAttributeBinding_getClassTypeId()

def SoVertexAttributeBinding_initClass():
  """SoVertexAttributeBinding_initClass()"""
  return _coin.SoVertexAttributeBinding_initClass()

class SoNormal(SoNode):
    """Proxy of C++ SoNormal class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoNormal_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoNormal_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoNormal_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoNormal"""
        this = _coin.new_SoNormal()
        try: self.this.append(this)
        except: self.this = this
    vector = _swig_property(_coin.SoNormal_vector_get, _coin.SoNormal_vector_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoNormal_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoNormal_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoNormal_callback(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoNormal_pick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoNormal_getPrimitiveCount(self, *args)

SoNormal_swigregister = _coin.SoNormal_swigregister
SoNormal_swigregister(SoNormal)

def SoNormal_getClassTypeId():
  """SoNormal_getClassTypeId() -> SoType"""
  return _coin.SoNormal_getClassTypeId()

def SoNormal_initClass():
  """SoNormal_initClass()"""
  return _coin.SoNormal_initClass()

class SoPackedColor(SoNode):
    """Proxy of C++ SoPackedColor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoPackedColor_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoPackedColor_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoPackedColor_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoPackedColor"""
        this = _coin.new_SoPackedColor()
        try: self.this.append(this)
        except: self.this = this
    orderedRGBA = _swig_property(_coin.SoPackedColor_orderedRGBA_get, _coin.SoPackedColor_orderedRGBA_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoPackedColor_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoPackedColor_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoPackedColor_callback(self, *args)

    def isTransparent(self):
        """isTransparent(self) -> SbBool"""
        return _coin.SoPackedColor_isTransparent(self)

SoPackedColor_swigregister = _coin.SoPackedColor_swigregister
SoPackedColor_swigregister(SoPackedColor)

def SoPackedColor_getClassTypeId():
  """SoPackedColor_getClassTypeId() -> SoType"""
  return _coin.SoPackedColor_getClassTypeId()

def SoPackedColor_initClass():
  """SoPackedColor_initClass()"""
  return _coin.SoPackedColor_initClass()

class SoPolygonOffset(SoNode):
    """Proxy of C++ SoPolygonOffset class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoPolygonOffset_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoPolygonOffset_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoPolygonOffset_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoPolygonOffset"""
        this = _coin.new_SoPolygonOffset()
        try: self.this.append(this)
        except: self.this = this
    FILLED = _coin.SoPolygonOffset_FILLED
    LINES = _coin.SoPolygonOffset_LINES
    POINTS = _coin.SoPolygonOffset_POINTS
    factor = _swig_property(_coin.SoPolygonOffset_factor_get, _coin.SoPolygonOffset_factor_set)
    units = _swig_property(_coin.SoPolygonOffset_units_get, _coin.SoPolygonOffset_units_set)
    styles = _swig_property(_coin.SoPolygonOffset_styles_get, _coin.SoPolygonOffset_styles_set)
    on = _swig_property(_coin.SoPolygonOffset_on_get, _coin.SoPolygonOffset_on_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoPolygonOffset_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoPolygonOffset_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoPolygonOffset_GLRender(self, *args)

SoPolygonOffset_swigregister = _coin.SoPolygonOffset_swigregister
SoPolygonOffset_swigregister(SoPolygonOffset)

def SoPolygonOffset_getClassTypeId():
  """SoPolygonOffset_getClassTypeId() -> SoType"""
  return _coin.SoPolygonOffset_getClassTypeId()

def SoPolygonOffset_initClass():
  """SoPolygonOffset_initClass()"""
  return _coin.SoPolygonOffset_initClass()

class SoProfileCoordinate2(SoNode):
    """Proxy of C++ SoProfileCoordinate2 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoProfileCoordinate2_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoProfileCoordinate2_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoProfileCoordinate2_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoProfileCoordinate2"""
        this = _coin.new_SoProfileCoordinate2()
        try: self.this.append(this)
        except: self.this = this
    point = _swig_property(_coin.SoProfileCoordinate2_point_get, _coin.SoProfileCoordinate2_point_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoProfileCoordinate2_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoProfileCoordinate2_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoProfileCoordinate2_callback(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoProfileCoordinate2_pick(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoProfileCoordinate2_getBoundingBox(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoProfileCoordinate2_getPrimitiveCount(self, *args)

SoProfileCoordinate2_swigregister = _coin.SoProfileCoordinate2_swigregister
SoProfileCoordinate2_swigregister(SoProfileCoordinate2)

def SoProfileCoordinate2_getClassTypeId():
  """SoProfileCoordinate2_getClassTypeId() -> SoType"""
  return _coin.SoProfileCoordinate2_getClassTypeId()

def SoProfileCoordinate2_initClass():
  """SoProfileCoordinate2_initClass()"""
  return _coin.SoProfileCoordinate2_initClass()

class SoProfileCoordinate3(SoNode):
    """Proxy of C++ SoProfileCoordinate3 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoProfileCoordinate3_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoProfileCoordinate3_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoProfileCoordinate3_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoProfileCoordinate3"""
        this = _coin.new_SoProfileCoordinate3()
        try: self.this.append(this)
        except: self.this = this
    point = _swig_property(_coin.SoProfileCoordinate3_point_get, _coin.SoProfileCoordinate3_point_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoProfileCoordinate3_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoProfileCoordinate3_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoProfileCoordinate3_callback(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoProfileCoordinate3_pick(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoProfileCoordinate3_getBoundingBox(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoProfileCoordinate3_getPrimitiveCount(self, *args)

SoProfileCoordinate3_swigregister = _coin.SoProfileCoordinate3_swigregister
SoProfileCoordinate3_swigregister(SoProfileCoordinate3)

def SoProfileCoordinate3_getClassTypeId():
  """SoProfileCoordinate3_getClassTypeId() -> SoType"""
  return _coin.SoProfileCoordinate3_getClassTypeId()

def SoProfileCoordinate3_initClass():
  """SoProfileCoordinate3_initClass()"""
  return _coin.SoProfileCoordinate3_initClass()

class SoTexture3(SoTexture):
    """Proxy of C++ SoTexture3 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTexture3_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTexture3_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTexture3_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTexture3"""
        this = _coin.new_SoTexture3()
        try: self.this.append(this)
        except: self.this = this
    MODULATE = _coin.SoTexture3_MODULATE
    DECAL = _coin.SoTexture3_DECAL
    BLEND = _coin.SoTexture3_BLEND
    REPEAT = _coin.SoTexture3_REPEAT
    CLAMP = _coin.SoTexture3_CLAMP
    filenames = _swig_property(_coin.SoTexture3_filenames_get, _coin.SoTexture3_filenames_set)
    images = _swig_property(_coin.SoTexture3_images_get, _coin.SoTexture3_images_set)
    wrapR = _swig_property(_coin.SoTexture3_wrapR_get, _coin.SoTexture3_wrapR_set)
    wrapS = _swig_property(_coin.SoTexture3_wrapS_get, _coin.SoTexture3_wrapS_set)
    wrapT = _swig_property(_coin.SoTexture3_wrapT_get, _coin.SoTexture3_wrapT_set)
    model = _swig_property(_coin.SoTexture3_model_get, _coin.SoTexture3_model_set)
    blendColor = _swig_property(_coin.SoTexture3_blendColor_get, _coin.SoTexture3_blendColor_set)
    enableCompressedTexture = _swig_property(_coin.SoTexture3_enableCompressedTexture_get, _coin.SoTexture3_enableCompressedTexture_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoTexture3_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoTexture3_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoTexture3_callback(self, *args)

SoTexture3_swigregister = _coin.SoTexture3_swigregister
SoTexture3_swigregister(SoTexture3)

def SoTexture3_getClassTypeId():
  """SoTexture3_getClassTypeId() -> SoType"""
  return _coin.SoTexture3_getClassTypeId()

def SoTexture3_initClass():
  """SoTexture3_initClass()"""
  return _coin.SoTexture3_initClass()

class SoTexture2Transform(SoNode):
    """Proxy of C++ SoTexture2Transform class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTexture2Transform_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTexture2Transform_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTexture2Transform_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTexture2Transform"""
        this = _coin.new_SoTexture2Transform()
        try: self.this.append(this)
        except: self.this = this
    translation = _swig_property(_coin.SoTexture2Transform_translation_get, _coin.SoTexture2Transform_translation_set)
    rotation = _swig_property(_coin.SoTexture2Transform_rotation_get, _coin.SoTexture2Transform_rotation_set)
    scaleFactor = _swig_property(_coin.SoTexture2Transform_scaleFactor_get, _coin.SoTexture2Transform_scaleFactor_set)
    center = _swig_property(_coin.SoTexture2Transform_center_get, _coin.SoTexture2Transform_center_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoTexture2Transform_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoTexture2Transform_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoTexture2Transform_GLRender(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoTexture2Transform_getMatrix(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoTexture2Transform_pick(self, *args)

SoTexture2Transform_swigregister = _coin.SoTexture2Transform_swigregister
SoTexture2Transform_swigregister(SoTexture2Transform)

def SoTexture2Transform_getClassTypeId():
  """SoTexture2Transform_getClassTypeId() -> SoType"""
  return _coin.SoTexture2Transform_getClassTypeId()

def SoTexture2Transform_initClass():
  """SoTexture2Transform_initClass()"""
  return _coin.SoTexture2Transform_initClass()

class SoTexture3Transform(SoNode):
    """Proxy of C++ SoTexture3Transform class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTexture3Transform_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTexture3Transform_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTexture3Transform_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTexture3Transform"""
        this = _coin.new_SoTexture3Transform()
        try: self.this.append(this)
        except: self.this = this
    translation = _swig_property(_coin.SoTexture3Transform_translation_get, _coin.SoTexture3Transform_translation_set)
    rotation = _swig_property(_coin.SoTexture3Transform_rotation_get, _coin.SoTexture3Transform_rotation_set)
    scaleFactor = _swig_property(_coin.SoTexture3Transform_scaleFactor_get, _coin.SoTexture3Transform_scaleFactor_set)
    scaleOrientation = _swig_property(_coin.SoTexture3Transform_scaleOrientation_get, _coin.SoTexture3Transform_scaleOrientation_set)
    center = _swig_property(_coin.SoTexture3Transform_center_get, _coin.SoTexture3Transform_center_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoTexture3Transform_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoTexture3Transform_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoTexture3Transform_GLRender(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoTexture3Transform_getMatrix(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoTexture3Transform_pick(self, *args)

SoTexture3Transform_swigregister = _coin.SoTexture3Transform_swigregister
SoTexture3Transform_swigregister(SoTexture3Transform)

def SoTexture3Transform_getClassTypeId():
  """SoTexture3Transform_getClassTypeId() -> SoType"""
  return _coin.SoTexture3Transform_getClassTypeId()

def SoTexture3Transform_initClass():
  """SoTexture3Transform_initClass()"""
  return _coin.SoTexture3Transform_initClass()

class SoTextureCoordinate2(SoNode):
    """Proxy of C++ SoTextureCoordinate2 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinate2_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTextureCoordinate2_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTextureCoordinate2_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTextureCoordinate2"""
        this = _coin.new_SoTextureCoordinate2()
        try: self.this.append(this)
        except: self.this = this
    point = _swig_property(_coin.SoTextureCoordinate2_point_get, _coin.SoTextureCoordinate2_point_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoTextureCoordinate2_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinate2_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinate2_callback(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoTextureCoordinate2_pick(self, *args)

SoTextureCoordinate2_swigregister = _coin.SoTextureCoordinate2_swigregister
SoTextureCoordinate2_swigregister(SoTextureCoordinate2)

def SoTextureCoordinate2_getClassTypeId():
  """SoTextureCoordinate2_getClassTypeId() -> SoType"""
  return _coin.SoTextureCoordinate2_getClassTypeId()

def SoTextureCoordinate2_initClass():
  """SoTextureCoordinate2_initClass()"""
  return _coin.SoTextureCoordinate2_initClass()

class SoTextureCoordinate3(SoNode):
    """Proxy of C++ SoTextureCoordinate3 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinate3_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTextureCoordinate3_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTextureCoordinate3_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTextureCoordinate3"""
        this = _coin.new_SoTextureCoordinate3()
        try: self.this.append(this)
        except: self.this = this
    point = _swig_property(_coin.SoTextureCoordinate3_point_get, _coin.SoTextureCoordinate3_point_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoTextureCoordinate3_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinate3_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinate3_callback(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoTextureCoordinate3_pick(self, *args)

SoTextureCoordinate3_swigregister = _coin.SoTextureCoordinate3_swigregister
SoTextureCoordinate3_swigregister(SoTextureCoordinate3)

def SoTextureCoordinate3_getClassTypeId():
  """SoTextureCoordinate3_getClassTypeId() -> SoType"""
  return _coin.SoTextureCoordinate3_getClassTypeId()

def SoTextureCoordinate3_initClass():
  """SoTextureCoordinate3_initClass()"""
  return _coin.SoTextureCoordinate3_initClass()

class SoTextureCoordinateFunction(SoNode):
    """Proxy of C++ SoTextureCoordinateFunction class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateFunction_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTextureCoordinateFunction_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTextureCoordinateFunction_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTextureCoordinateFunction"""
        this = _coin.new_SoTextureCoordinateFunction()
        try: self.this.append(this)
        except: self.this = this
SoTextureCoordinateFunction_swigregister = _coin.SoTextureCoordinateFunction_swigregister
SoTextureCoordinateFunction_swigregister(SoTextureCoordinateFunction)

def SoTextureCoordinateFunction_getClassTypeId():
  """SoTextureCoordinateFunction_getClassTypeId() -> SoType"""
  return _coin.SoTextureCoordinateFunction_getClassTypeId()

def SoTextureCoordinateFunction_initClass():
  """SoTextureCoordinateFunction_initClass()"""
  return _coin.SoTextureCoordinateFunction_initClass()

class SoTextureCoordinateDefault(SoTextureCoordinateFunction):
    """Proxy of C++ SoTextureCoordinateDefault class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateDefault_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTextureCoordinateDefault_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTextureCoordinateDefault_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTextureCoordinateDefault"""
        this = _coin.new_SoTextureCoordinateDefault()
        try: self.this.append(this)
        except: self.this = this
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoTextureCoordinateDefault_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateDefault_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateDefault_callback(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoTextureCoordinateDefault_pick(self, *args)

SoTextureCoordinateDefault_swigregister = _coin.SoTextureCoordinateDefault_swigregister
SoTextureCoordinateDefault_swigregister(SoTextureCoordinateDefault)

def SoTextureCoordinateDefault_getClassTypeId():
  """SoTextureCoordinateDefault_getClassTypeId() -> SoType"""
  return _coin.SoTextureCoordinateDefault_getClassTypeId()

def SoTextureCoordinateDefault_initClass():
  """SoTextureCoordinateDefault_initClass()"""
  return _coin.SoTextureCoordinateDefault_initClass()

class SoTextureCoordinateEnvironment(SoTextureCoordinateFunction):
    """Proxy of C++ SoTextureCoordinateEnvironment class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateEnvironment_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTextureCoordinateEnvironment_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTextureCoordinateEnvironment_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTextureCoordinateEnvironment"""
        this = _coin.new_SoTextureCoordinateEnvironment()
        try: self.this.append(this)
        except: self.this = this
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoTextureCoordinateEnvironment_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateEnvironment_GLRender(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoTextureCoordinateEnvironment_pick(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateEnvironment_callback(self, *args)

SoTextureCoordinateEnvironment_swigregister = _coin.SoTextureCoordinateEnvironment_swigregister
SoTextureCoordinateEnvironment_swigregister(SoTextureCoordinateEnvironment)

def SoTextureCoordinateEnvironment_getClassTypeId():
  """SoTextureCoordinateEnvironment_getClassTypeId() -> SoType"""
  return _coin.SoTextureCoordinateEnvironment_getClassTypeId()

def SoTextureCoordinateEnvironment_initClass():
  """SoTextureCoordinateEnvironment_initClass()"""
  return _coin.SoTextureCoordinateEnvironment_initClass()

class SoTextureCoordinatePlane(SoTextureCoordinateFunction):
    """Proxy of C++ SoTextureCoordinatePlane class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinatePlane_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTextureCoordinatePlane_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTextureCoordinatePlane_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTextureCoordinatePlane"""
        this = _coin.new_SoTextureCoordinatePlane()
        try: self.this.append(this)
        except: self.this = this
    directionS = _swig_property(_coin.SoTextureCoordinatePlane_directionS_get, _coin.SoTextureCoordinatePlane_directionS_set)
    directionT = _swig_property(_coin.SoTextureCoordinatePlane_directionT_get, _coin.SoTextureCoordinatePlane_directionT_set)
    directionR = _swig_property(_coin.SoTextureCoordinatePlane_directionR_get, _coin.SoTextureCoordinatePlane_directionR_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoTextureCoordinatePlane_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinatePlane_GLRender(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoTextureCoordinatePlane_pick(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinatePlane_callback(self, *args)

SoTextureCoordinatePlane_swigregister = _coin.SoTextureCoordinatePlane_swigregister
SoTextureCoordinatePlane_swigregister(SoTextureCoordinatePlane)

def SoTextureCoordinatePlane_getClassTypeId():
  """SoTextureCoordinatePlane_getClassTypeId() -> SoType"""
  return _coin.SoTextureCoordinatePlane_getClassTypeId()

def SoTextureCoordinatePlane_initClass():
  """SoTextureCoordinatePlane_initClass()"""
  return _coin.SoTextureCoordinatePlane_initClass()

class SoTextureMatrixTransform(SoNode):
    """Proxy of C++ SoTextureMatrixTransform class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextureMatrixTransform_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTextureMatrixTransform_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTextureMatrixTransform_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTextureMatrixTransform"""
        this = _coin.new_SoTextureMatrixTransform()
        try: self.this.append(this)
        except: self.this = this
    matrix = _swig_property(_coin.SoTextureMatrixTransform_matrix_get, _coin.SoTextureMatrixTransform_matrix_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoTextureMatrixTransform_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoTextureMatrixTransform_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoTextureMatrixTransform_GLRender(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoTextureMatrixTransform_getMatrix(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoTextureMatrixTransform_pick(self, *args)

SoTextureMatrixTransform_swigregister = _coin.SoTextureMatrixTransform_swigregister
SoTextureMatrixTransform_swigregister(SoTextureMatrixTransform)

def SoTextureMatrixTransform_getClassTypeId():
  """SoTextureMatrixTransform_getClassTypeId() -> SoType"""
  return _coin.SoTextureMatrixTransform_getClassTypeId()

def SoTextureMatrixTransform_initClass():
  """SoTextureMatrixTransform_initClass()"""
  return _coin.SoTextureMatrixTransform_initClass()

class SoWWWInline(SoNode):
    """Proxy of C++ SoWWWInline class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoWWWInline_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoWWWInline_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoWWWInline_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoWWWInline"""
        this = _coin.new_SoWWWInline()
        try: self.this.append(this)
        except: self.this = this
    name = _swig_property(_coin.SoWWWInline_name_get, _coin.SoWWWInline_name_set)
    bboxCenter = _swig_property(_coin.SoWWWInline_bboxCenter_get, _coin.SoWWWInline_bboxCenter_set)
    bboxSize = _swig_property(_coin.SoWWWInline_bboxSize_get, _coin.SoWWWInline_bboxSize_set)
    alternateRep = _swig_property(_coin.SoWWWInline_alternateRep_get, _coin.SoWWWInline_alternateRep_set)
    NEVER = _coin.SoWWWInline_NEVER
    UNTIL_LOADED = _coin.SoWWWInline_UNTIL_LOADED
    ALWAYS = _coin.SoWWWInline_ALWAYS
    def setFullURLName(self, *args):
        """setFullURLName(self, SbString url)"""
        return _coin.SoWWWInline_setFullURLName(self, *args)

    def getFullURLName(self):
        """getFullURLName(self) -> SbString"""
        return _coin.SoWWWInline_getFullURLName(self)

    def copyChildren(self):
        """copyChildren(self) -> SoGroup"""
        return _coin.SoWWWInline_copyChildren(self)

    def requestURLData(self):
        """requestURLData(self)"""
        return _coin.SoWWWInline_requestURLData(self)

    def isURLDataRequested(self):
        """isURLDataRequested(self) -> SbBool"""
        return _coin.SoWWWInline_isURLDataRequested(self)

    def isURLDataHere(self):
        """isURLDataHere(self) -> SbBool"""
        return _coin.SoWWWInline_isURLDataHere(self)

    def cancelURLDataRequest(self):
        """cancelURLDataRequest(self)"""
        return _coin.SoWWWInline_cancelURLDataRequest(self)

    def setChildData(self, *args):
        """setChildData(self, SoNode urldata)"""
        return _coin.SoWWWInline_setChildData(self, *args)

    def getChildData(self):
        """getChildData(self) -> SoNode"""
        return _coin.SoWWWInline_getChildData(self)

    def getChildren(self):
        """getChildren(self) -> SoChildList"""
        return _coin.SoWWWInline_getChildren(self)

    def setFetchURLCallBack(*args):
        """setFetchURLCallBack(SoWWWInlineFetchURLCB f, void userdata)"""
        return _coin.SoWWWInline_setFetchURLCallBack(*args)

    setFetchURLCallBack = staticmethod(setFetchURLCallBack)
    def setBoundingBoxVisibility(*args):
        """setBoundingBoxVisibility(BboxVisibility b)"""
        return _coin.SoWWWInline_setBoundingBoxVisibility(*args)

    setBoundingBoxVisibility = staticmethod(setBoundingBoxVisibility)
    def getBoundingBoxVisibility():
        """getBoundingBoxVisibility() -> BboxVisibility"""
        return _coin.SoWWWInline_getBoundingBoxVisibility()

    getBoundingBoxVisibility = staticmethod(getBoundingBoxVisibility)
    def setBoundingBoxColor(*args):
        """setBoundingBoxColor(SbColor c)"""
        return _coin.SoWWWInline_setBoundingBoxColor(*args)

    setBoundingBoxColor = staticmethod(setBoundingBoxColor)
    def getBoundingBoxColor():
        """getBoundingBoxColor() -> SbColor"""
        return _coin.SoWWWInline_getBoundingBoxColor()

    getBoundingBoxColor = staticmethod(getBoundingBoxColor)
    def setReadAsSoFile(*args):
        """setReadAsSoFile(SbBool onoff)"""
        return _coin.SoWWWInline_setReadAsSoFile(*args)

    setReadAsSoFile = staticmethod(setReadAsSoFile)
    def getReadAsSoFile():
        """getReadAsSoFile() -> SbBool"""
        return _coin.SoWWWInline_getReadAsSoFile()

    getReadAsSoFile = staticmethod(getReadAsSoFile)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoWWWInline_doAction(self, *args)

    def doActionOnKidsOrBox(self, *args):
        """doActionOnKidsOrBox(self, SoAction action)"""
        return _coin.SoWWWInline_doActionOnKidsOrBox(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoWWWInline_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoWWWInline_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoWWWInline_getBoundingBox(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoWWWInline_getMatrix(self, *args)

    def handleEvent(self, *args):
        """handleEvent(self, SoHandleEventAction action)"""
        return _coin.SoWWWInline_handleEvent(self, *args)

    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoWWWInline_search(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoWWWInline_pick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoWWWInline_getPrimitiveCount(self, *args)

    def audioRender(self, *args):
        """audioRender(self, SoAudioRenderAction action)"""
        return _coin.SoWWWInline_audioRender(self, *args)

SoWWWInline_swigregister = _coin.SoWWWInline_swigregister
SoWWWInline_swigregister(SoWWWInline)

def SoWWWInline_getClassTypeId():
  """SoWWWInline_getClassTypeId() -> SoType"""
  return _coin.SoWWWInline_getClassTypeId()

def SoWWWInline_initClass():
  """SoWWWInline_initClass()"""
  return _coin.SoWWWInline_initClass()

def SoWWWInline_setFetchURLCallBack(*args):
  """SoWWWInline_setFetchURLCallBack(SoWWWInlineFetchURLCB f, void userdata)"""
  return _coin.SoWWWInline_setFetchURLCallBack(*args)

def SoWWWInline_setBoundingBoxVisibility(*args):
  """SoWWWInline_setBoundingBoxVisibility(BboxVisibility b)"""
  return _coin.SoWWWInline_setBoundingBoxVisibility(*args)

def SoWWWInline_getBoundingBoxVisibility():
  """SoWWWInline_getBoundingBoxVisibility() -> BboxVisibility"""
  return _coin.SoWWWInline_getBoundingBoxVisibility()

def SoWWWInline_setBoundingBoxColor(*args):
  """SoWWWInline_setBoundingBoxColor(SbColor c)"""
  return _coin.SoWWWInline_setBoundingBoxColor(*args)

def SoWWWInline_getBoundingBoxColor():
  """SoWWWInline_getBoundingBoxColor() -> SbColor"""
  return _coin.SoWWWInline_getBoundingBoxColor()

def SoWWWInline_setReadAsSoFile(*args):
  """SoWWWInline_setReadAsSoFile(SbBool onoff)"""
  return _coin.SoWWWInline_setReadAsSoFile(*args)

def SoWWWInline_getReadAsSoFile():
  """SoWWWInline_getReadAsSoFile() -> SbBool"""
  return _coin.SoWWWInline_getReadAsSoFile()

class SoTransparencyType(SoNode):
    """Proxy of C++ SoTransparencyType class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTransparencyType_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTransparencyType_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTransparencyType_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTransparencyType"""
        this = _coin.new_SoTransparencyType()
        try: self.this.append(this)
        except: self.this = this
    SCREEN_DOOR = _coin.SoTransparencyType_SCREEN_DOOR
    ADD = _coin.SoTransparencyType_ADD
    DELAYED_ADD = _coin.SoTransparencyType_DELAYED_ADD
    SORTED_OBJECT_ADD = _coin.SoTransparencyType_SORTED_OBJECT_ADD
    BLEND = _coin.SoTransparencyType_BLEND
    DELAYED_BLEND = _coin.SoTransparencyType_DELAYED_BLEND
    SORTED_OBJECT_BLEND = _coin.SoTransparencyType_SORTED_OBJECT_BLEND
    SORTED_OBJECT_SORTED_TRIANGLE_ADD = _coin.SoTransparencyType_SORTED_OBJECT_SORTED_TRIANGLE_ADD
    SORTED_OBJECT_SORTED_TRIANGLE_BLEND = _coin.SoTransparencyType_SORTED_OBJECT_SORTED_TRIANGLE_BLEND
    NONE = _coin.SoTransparencyType_NONE
    value = _swig_property(_coin.SoTransparencyType_value_get, _coin.SoTransparencyType_value_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoTransparencyType_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoTransparencyType_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoTransparencyType_callback(self, *args)

SoTransparencyType_swigregister = _coin.SoTransparencyType_swigregister
SoTransparencyType_swigregister(SoTransparencyType)

def SoTransparencyType_getClassTypeId():
  """SoTransparencyType_getClassTypeId() -> SoType"""
  return _coin.SoTransparencyType_getClassTypeId()

def SoTransparencyType_initClass():
  """SoTransparencyType_initClass()"""
  return _coin.SoTransparencyType_initClass()

class SoTextureCoordinateCube(SoNode):
    """Proxy of C++ SoTextureCoordinateCube class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateCube_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTextureCoordinateCube_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTextureCoordinateCube_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTextureCoordinateCube"""
        this = _coin.new_SoTextureCoordinateCube()
        try: self.this.append(this)
        except: self.this = this
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoTextureCoordinateCube_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateCube_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateCube_callback(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoTextureCoordinateCube_pick(self, *args)

SoTextureCoordinateCube_swigregister = _coin.SoTextureCoordinateCube_swigregister
SoTextureCoordinateCube_swigregister(SoTextureCoordinateCube)

def SoTextureCoordinateCube_getClassTypeId():
  """SoTextureCoordinateCube_getClassTypeId() -> SoType"""
  return _coin.SoTextureCoordinateCube_getClassTypeId()

def SoTextureCoordinateCube_initClass():
  """SoTextureCoordinateCube_initClass()"""
  return _coin.SoTextureCoordinateCube_initClass()

class SoTextureCoordinateSphere(SoNode):
    """Proxy of C++ SoTextureCoordinateSphere class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateSphere_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTextureCoordinateSphere_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTextureCoordinateSphere_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTextureCoordinateSphere"""
        this = _coin.new_SoTextureCoordinateSphere()
        try: self.this.append(this)
        except: self.this = this
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoTextureCoordinateSphere_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateSphere_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateSphere_callback(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoTextureCoordinateSphere_pick(self, *args)

SoTextureCoordinateSphere_swigregister = _coin.SoTextureCoordinateSphere_swigregister
SoTextureCoordinateSphere_swigregister(SoTextureCoordinateSphere)

def SoTextureCoordinateSphere_getClassTypeId():
  """SoTextureCoordinateSphere_getClassTypeId() -> SoType"""
  return _coin.SoTextureCoordinateSphere_getClassTypeId()

def SoTextureCoordinateSphere_initClass():
  """SoTextureCoordinateSphere_initClass()"""
  return _coin.SoTextureCoordinateSphere_initClass()

class SoTextureCoordinateCylinder(SoNode):
    """Proxy of C++ SoTextureCoordinateCylinder class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateCylinder_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTextureCoordinateCylinder_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTextureCoordinateCylinder_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTextureCoordinateCylinder"""
        this = _coin.new_SoTextureCoordinateCylinder()
        try: self.this.append(this)
        except: self.this = this
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoTextureCoordinateCylinder_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateCylinder_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateCylinder_callback(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoTextureCoordinateCylinder_pick(self, *args)

SoTextureCoordinateCylinder_swigregister = _coin.SoTextureCoordinateCylinder_swigregister
SoTextureCoordinateCylinder_swigregister(SoTextureCoordinateCylinder)

def SoTextureCoordinateCylinder_getClassTypeId():
  """SoTextureCoordinateCylinder_getClassTypeId() -> SoType"""
  return _coin.SoTextureCoordinateCylinder_getClassTypeId()

def SoTextureCoordinateCylinder_initClass():
  """SoTextureCoordinateCylinder_initClass()"""
  return _coin.SoTextureCoordinateCylinder_initClass()

class SoTextureCubeMap(SoTexture):
    """Proxy of C++ SoTextureCubeMap class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextureCubeMap_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTextureCubeMap_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTextureCubeMap_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTextureCubeMap"""
        this = _coin.new_SoTextureCubeMap()
        try: self.this.append(this)
        except: self.this = this
    MODULATE = _coin.SoTextureCubeMap_MODULATE
    DECAL = _coin.SoTextureCubeMap_DECAL
    BLEND = _coin.SoTextureCubeMap_BLEND
    REPLACE = _coin.SoTextureCubeMap_REPLACE
    REPEAT = _coin.SoTextureCubeMap_REPEAT
    CLAMP = _coin.SoTextureCubeMap_CLAMP
    filenames = _swig_property(_coin.SoTextureCubeMap_filenames_get, _coin.SoTextureCubeMap_filenames_set)
    imagePosX = _swig_property(_coin.SoTextureCubeMap_imagePosX_get, _coin.SoTextureCubeMap_imagePosX_set)
    imageNegX = _swig_property(_coin.SoTextureCubeMap_imageNegX_get, _coin.SoTextureCubeMap_imageNegX_set)
    imagePosY = _swig_property(_coin.SoTextureCubeMap_imagePosY_get, _coin.SoTextureCubeMap_imagePosY_set)
    imageNegY = _swig_property(_coin.SoTextureCubeMap_imageNegY_get, _coin.SoTextureCubeMap_imageNegY_set)
    imagePosZ = _swig_property(_coin.SoTextureCubeMap_imagePosZ_get, _coin.SoTextureCubeMap_imagePosZ_set)
    imageNegZ = _swig_property(_coin.SoTextureCubeMap_imageNegZ_get, _coin.SoTextureCubeMap_imageNegZ_set)
    wrapS = _swig_property(_coin.SoTextureCubeMap_wrapS_get, _coin.SoTextureCubeMap_wrapS_set)
    wrapT = _swig_property(_coin.SoTextureCubeMap_wrapT_get, _coin.SoTextureCubeMap_wrapT_set)
    model = _swig_property(_coin.SoTextureCubeMap_model_get, _coin.SoTextureCubeMap_model_set)
    blendColor = _swig_property(_coin.SoTextureCubeMap_blendColor_get, _coin.SoTextureCubeMap_blendColor_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoTextureCubeMap_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoTextureCubeMap_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoTextureCubeMap_callback(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoTextureCubeMap_rayPick(self, *args)

    def readImage(*args):
        """readImage(SbString fname, int w, int h, int nc, unsigned char bytes) -> SbBool"""
        return _coin.SoTextureCubeMap_readImage(*args)

    readImage = staticmethod(readImage)
SoTextureCubeMap_swigregister = _coin.SoTextureCubeMap_swigregister
SoTextureCubeMap_swigregister(SoTextureCubeMap)

def SoTextureCubeMap_getClassTypeId():
  """SoTextureCubeMap_getClassTypeId() -> SoType"""
  return _coin.SoTextureCubeMap_getClassTypeId()

def SoTextureCubeMap_initClass():
  """SoTextureCubeMap_initClass()"""
  return _coin.SoTextureCubeMap_initClass()

def SoTextureCubeMap_readImage(*args):
  """SoTextureCubeMap_readImage(SbString fname, int w, int h, int nc, unsigned char bytes) -> SbBool"""
  return _coin.SoTextureCubeMap_readImage(*args)

class SoShaderObject(SoNode):
    """Proxy of C++ SoShaderObject class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShaderObject_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoShaderObject_getTypeId(self)

    ARB_PROGRAM = _coin.SoShaderObject_ARB_PROGRAM
    CG_PROGRAM = _coin.SoShaderObject_CG_PROGRAM
    GLSL_PROGRAM = _coin.SoShaderObject_GLSL_PROGRAM
    FILENAME = _coin.SoShaderObject_FILENAME
    isActive = _swig_property(_coin.SoShaderObject_isActive_get, _coin.SoShaderObject_isActive_set)
    sourceType = _swig_property(_coin.SoShaderObject_sourceType_get, _coin.SoShaderObject_sourceType_set)
    sourceProgram = _swig_property(_coin.SoShaderObject_sourceProgram_get, _coin.SoShaderObject_sourceProgram_set)
    parameter = _swig_property(_coin.SoShaderObject_parameter_get, _coin.SoShaderObject_parameter_set)
    def initClass():
        """initClass()"""
        return _coin.SoShaderObject_initClass()

    initClass = staticmethod(initClass)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoShaderObject_GLRender(self, *args)

    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoShaderObject_search(self, *args)

    def updateParameters(self, *args):
        """updateParameters(self, SoState state)"""
        return _coin.SoShaderObject_updateParameters(self, *args)

    def getSourceType(self):
        """getSourceType(self) -> SourceType"""
        return _coin.SoShaderObject_getSourceType(self)

    def getSourceProgram(self):
        """getSourceProgram(self) -> SbString"""
        return _coin.SoShaderObject_getSourceProgram(self)

SoShaderObject_swigregister = _coin.SoShaderObject_swigregister
SoShaderObject_swigregister(SoShaderObject)

def SoShaderObject_getClassTypeId():
  """SoShaderObject_getClassTypeId() -> SoType"""
  return _coin.SoShaderObject_getClassTypeId()

def SoShaderObject_initClass():
  """SoShaderObject_initClass()"""
  return _coin.SoShaderObject_initClass()

class SoShaderParameter(SoNode):
    """Proxy of C++ SoShaderParameter class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShaderParameter_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoShaderParameter_getTypeId(self)

    name = _swig_property(_coin.SoShaderParameter_name_get, _coin.SoShaderParameter_name_set)
    identifier = _swig_property(_coin.SoShaderParameter_identifier_get, _coin.SoShaderParameter_identifier_set)
    def initClass():
        """initClass()"""
        return _coin.SoShaderParameter_initClass()

    initClass = staticmethod(initClass)
SoShaderParameter_swigregister = _coin.SoShaderParameter_swigregister
SoShaderParameter_swigregister(SoShaderParameter)

def SoShaderParameter_getClassTypeId():
  """SoShaderParameter_getClassTypeId() -> SoType"""
  return _coin.SoShaderParameter_getClassTypeId()

def SoShaderParameter_initClass():
  """SoShaderParameter_initClass()"""
  return _coin.SoShaderParameter_initClass()

class SoUniformShaderParameter(SoShaderParameter):
    """Proxy of C++ SoUniformShaderParameter class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoUniformShaderParameter_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoUniformShaderParameter_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoUniformShaderParameter_initClass()

    initClass = staticmethod(initClass)
    def updateParameter(self, *args):
        """updateParameter(self, SoGLShaderObject shaderObject)"""
        return _coin.SoUniformShaderParameter_updateParameter(self, *args)

SoUniformShaderParameter_swigregister = _coin.SoUniformShaderParameter_swigregister
SoUniformShaderParameter_swigregister(SoUniformShaderParameter)

def SoUniformShaderParameter_getClassTypeId():
  """SoUniformShaderParameter_getClassTypeId() -> SoType"""
  return _coin.SoUniformShaderParameter_getClassTypeId()

def SoUniformShaderParameter_initClass():
  """SoUniformShaderParameter_initClass()"""
  return _coin.SoUniformShaderParameter_initClass()

class SoShaderParameter1f(SoUniformShaderParameter):
    """Proxy of C++ SoShaderParameter1f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShaderParameter1f_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoShaderParameter1f_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameter1f_value_get, _coin.SoShaderParameter1f_value_set)
    def __init__(self): 
        """__init__(self) -> SoShaderParameter1f"""
        this = _coin.new_SoShaderParameter1f()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoShaderParameter1f_initClass()

    initClass = staticmethod(initClass)
    def updateParameter(self, *args):
        """updateParameter(self, SoGLShaderObject shaderObject)"""
        return _coin.SoShaderParameter1f_updateParameter(self, *args)

SoShaderParameter1f_swigregister = _coin.SoShaderParameter1f_swigregister
SoShaderParameter1f_swigregister(SoShaderParameter1f)

def SoShaderParameter1f_getClassTypeId():
  """SoShaderParameter1f_getClassTypeId() -> SoType"""
  return _coin.SoShaderParameter1f_getClassTypeId()

def SoShaderParameter1f_initClass():
  """SoShaderParameter1f_initClass()"""
  return _coin.SoShaderParameter1f_initClass()

class SoShaderParameter1i(SoUniformShaderParameter):
    """Proxy of C++ SoShaderParameter1i class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShaderParameter1i_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoShaderParameter1i_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameter1i_value_get, _coin.SoShaderParameter1i_value_set)
    def __init__(self): 
        """__init__(self) -> SoShaderParameter1i"""
        this = _coin.new_SoShaderParameter1i()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoShaderParameter1i_initClass()

    initClass = staticmethod(initClass)
    def updateParameter(self, *args):
        """updateParameter(self, SoGLShaderObject shaderObject)"""
        return _coin.SoShaderParameter1i_updateParameter(self, *args)

SoShaderParameter1i_swigregister = _coin.SoShaderParameter1i_swigregister
SoShaderParameter1i_swigregister(SoShaderParameter1i)

def SoShaderParameter1i_getClassTypeId():
  """SoShaderParameter1i_getClassTypeId() -> SoType"""
  return _coin.SoShaderParameter1i_getClassTypeId()

def SoShaderParameter1i_initClass():
  """SoShaderParameter1i_initClass()"""
  return _coin.SoShaderParameter1i_initClass()

class SoShaderParameter2f(SoUniformShaderParameter):
    """Proxy of C++ SoShaderParameter2f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShaderParameter2f_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoShaderParameter2f_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameter2f_value_get, _coin.SoShaderParameter2f_value_set)
    def __init__(self): 
        """__init__(self) -> SoShaderParameter2f"""
        this = _coin.new_SoShaderParameter2f()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoShaderParameter2f_initClass()

    initClass = staticmethod(initClass)
    def updateParameter(self, *args):
        """updateParameter(self, SoGLShaderObject shaderObject)"""
        return _coin.SoShaderParameter2f_updateParameter(self, *args)

SoShaderParameter2f_swigregister = _coin.SoShaderParameter2f_swigregister
SoShaderParameter2f_swigregister(SoShaderParameter2f)

def SoShaderParameter2f_getClassTypeId():
  """SoShaderParameter2f_getClassTypeId() -> SoType"""
  return _coin.SoShaderParameter2f_getClassTypeId()

def SoShaderParameter2f_initClass():
  """SoShaderParameter2f_initClass()"""
  return _coin.SoShaderParameter2f_initClass()

class SoShaderParameter2i(SoUniformShaderParameter):
    """Proxy of C++ SoShaderParameter2i class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShaderParameter2i_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoShaderParameter2i_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameter2i_value_get, _coin.SoShaderParameter2i_value_set)
    def __init__(self): 
        """__init__(self) -> SoShaderParameter2i"""
        this = _coin.new_SoShaderParameter2i()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoShaderParameter2i_initClass()

    initClass = staticmethod(initClass)
    def updateParameter(self, *args):
        """updateParameter(self, SoGLShaderObject shaderObject)"""
        return _coin.SoShaderParameter2i_updateParameter(self, *args)

SoShaderParameter2i_swigregister = _coin.SoShaderParameter2i_swigregister
SoShaderParameter2i_swigregister(SoShaderParameter2i)

def SoShaderParameter2i_getClassTypeId():
  """SoShaderParameter2i_getClassTypeId() -> SoType"""
  return _coin.SoShaderParameter2i_getClassTypeId()

def SoShaderParameter2i_initClass():
  """SoShaderParameter2i_initClass()"""
  return _coin.SoShaderParameter2i_initClass()

class SoShaderParameter3f(SoUniformShaderParameter):
    """Proxy of C++ SoShaderParameter3f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShaderParameter3f_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoShaderParameter3f_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameter3f_value_get, _coin.SoShaderParameter3f_value_set)
    def __init__(self): 
        """__init__(self) -> SoShaderParameter3f"""
        this = _coin.new_SoShaderParameter3f()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoShaderParameter3f_initClass()

    initClass = staticmethod(initClass)
    def updateParameter(self, *args):
        """updateParameter(self, SoGLShaderObject shaderObject)"""
        return _coin.SoShaderParameter3f_updateParameter(self, *args)

SoShaderParameter3f_swigregister = _coin.SoShaderParameter3f_swigregister
SoShaderParameter3f_swigregister(SoShaderParameter3f)

def SoShaderParameter3f_getClassTypeId():
  """SoShaderParameter3f_getClassTypeId() -> SoType"""
  return _coin.SoShaderParameter3f_getClassTypeId()

def SoShaderParameter3f_initClass():
  """SoShaderParameter3f_initClass()"""
  return _coin.SoShaderParameter3f_initClass()

class SoShaderParameter3i(SoUniformShaderParameter):
    """Proxy of C++ SoShaderParameter3i class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShaderParameter3i_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoShaderParameter3i_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameter3i_value_get, _coin.SoShaderParameter3i_value_set)
    def __init__(self): 
        """__init__(self) -> SoShaderParameter3i"""
        this = _coin.new_SoShaderParameter3i()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoShaderParameter3i_initClass()

    initClass = staticmethod(initClass)
    def updateParameter(self, *args):
        """updateParameter(self, SoGLShaderObject shaderObject)"""
        return _coin.SoShaderParameter3i_updateParameter(self, *args)

SoShaderParameter3i_swigregister = _coin.SoShaderParameter3i_swigregister
SoShaderParameter3i_swigregister(SoShaderParameter3i)

def SoShaderParameter3i_getClassTypeId():
  """SoShaderParameter3i_getClassTypeId() -> SoType"""
  return _coin.SoShaderParameter3i_getClassTypeId()

def SoShaderParameter3i_initClass():
  """SoShaderParameter3i_initClass()"""
  return _coin.SoShaderParameter3i_initClass()

class SoShaderParameter4f(SoUniformShaderParameter):
    """Proxy of C++ SoShaderParameter4f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShaderParameter4f_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoShaderParameter4f_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameter4f_value_get, _coin.SoShaderParameter4f_value_set)
    def __init__(self): 
        """__init__(self) -> SoShaderParameter4f"""
        this = _coin.new_SoShaderParameter4f()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoShaderParameter4f_initClass()

    initClass = staticmethod(initClass)
    def updateParameter(self, *args):
        """updateParameter(self, SoGLShaderObject shaderObject)"""
        return _coin.SoShaderParameter4f_updateParameter(self, *args)

SoShaderParameter4f_swigregister = _coin.SoShaderParameter4f_swigregister
SoShaderParameter4f_swigregister(SoShaderParameter4f)

def SoShaderParameter4f_getClassTypeId():
  """SoShaderParameter4f_getClassTypeId() -> SoType"""
  return _coin.SoShaderParameter4f_getClassTypeId()

def SoShaderParameter4f_initClass():
  """SoShaderParameter4f_initClass()"""
  return _coin.SoShaderParameter4f_initClass()

class SoShaderParameter4i(SoUniformShaderParameter):
    """Proxy of C++ SoShaderParameter4i class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShaderParameter4i_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoShaderParameter4i_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameter4i_value_get, _coin.SoShaderParameter4i_value_set)
    def __init__(self): 
        """__init__(self) -> SoShaderParameter4i"""
        this = _coin.new_SoShaderParameter4i()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoShaderParameter4i_initClass()

    initClass = staticmethod(initClass)
    def updateParameter(self, *args):
        """updateParameter(self, SoGLShaderObject shaderObject)"""
        return _coin.SoShaderParameter4i_updateParameter(self, *args)

SoShaderParameter4i_swigregister = _coin.SoShaderParameter4i_swigregister
SoShaderParameter4i_swigregister(SoShaderParameter4i)

def SoShaderParameter4i_getClassTypeId():
  """SoShaderParameter4i_getClassTypeId() -> SoType"""
  return _coin.SoShaderParameter4i_getClassTypeId()

def SoShaderParameter4i_initClass():
  """SoShaderParameter4i_initClass()"""
  return _coin.SoShaderParameter4i_initClass()

class SoShaderParameterArray1f(SoUniformShaderParameter):
    """Proxy of C++ SoShaderParameterArray1f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterArray1f_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoShaderParameterArray1f_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameterArray1f_value_get, _coin.SoShaderParameterArray1f_value_set)
    def __init__(self): 
        """__init__(self) -> SoShaderParameterArray1f"""
        this = _coin.new_SoShaderParameterArray1f()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoShaderParameterArray1f_initClass()

    initClass = staticmethod(initClass)
    def updateParameter(self, *args):
        """updateParameter(self, SoGLShaderObject shaderObject)"""
        return _coin.SoShaderParameterArray1f_updateParameter(self, *args)

SoShaderParameterArray1f_swigregister = _coin.SoShaderParameterArray1f_swigregister
SoShaderParameterArray1f_swigregister(SoShaderParameterArray1f)

def SoShaderParameterArray1f_getClassTypeId():
  """SoShaderParameterArray1f_getClassTypeId() -> SoType"""
  return _coin.SoShaderParameterArray1f_getClassTypeId()

def SoShaderParameterArray1f_initClass():
  """SoShaderParameterArray1f_initClass()"""
  return _coin.SoShaderParameterArray1f_initClass()

class SoShaderParameterArray1i(SoUniformShaderParameter):
    """Proxy of C++ SoShaderParameterArray1i class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterArray1i_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoShaderParameterArray1i_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameterArray1i_value_get, _coin.SoShaderParameterArray1i_value_set)
    def __init__(self): 
        """__init__(self) -> SoShaderParameterArray1i"""
        this = _coin.new_SoShaderParameterArray1i()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoShaderParameterArray1i_initClass()

    initClass = staticmethod(initClass)
    def updateParameter(self, *args):
        """updateParameter(self, SoGLShaderObject shaderObject)"""
        return _coin.SoShaderParameterArray1i_updateParameter(self, *args)

SoShaderParameterArray1i_swigregister = _coin.SoShaderParameterArray1i_swigregister
SoShaderParameterArray1i_swigregister(SoShaderParameterArray1i)

def SoShaderParameterArray1i_getClassTypeId():
  """SoShaderParameterArray1i_getClassTypeId() -> SoType"""
  return _coin.SoShaderParameterArray1i_getClassTypeId()

def SoShaderParameterArray1i_initClass():
  """SoShaderParameterArray1i_initClass()"""
  return _coin.SoShaderParameterArray1i_initClass()

class SoShaderParameterArray2f(SoUniformShaderParameter):
    """Proxy of C++ SoShaderParameterArray2f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterArray2f_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoShaderParameterArray2f_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameterArray2f_value_get, _coin.SoShaderParameterArray2f_value_set)
    def __init__(self): 
        """__init__(self) -> SoShaderParameterArray2f"""
        this = _coin.new_SoShaderParameterArray2f()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoShaderParameterArray2f_initClass()

    initClass = staticmethod(initClass)
    def updateParameter(self, *args):
        """updateParameter(self, SoGLShaderObject shaderObject)"""
        return _coin.SoShaderParameterArray2f_updateParameter(self, *args)

SoShaderParameterArray2f_swigregister = _coin.SoShaderParameterArray2f_swigregister
SoShaderParameterArray2f_swigregister(SoShaderParameterArray2f)

def SoShaderParameterArray2f_getClassTypeId():
  """SoShaderParameterArray2f_getClassTypeId() -> SoType"""
  return _coin.SoShaderParameterArray2f_getClassTypeId()

def SoShaderParameterArray2f_initClass():
  """SoShaderParameterArray2f_initClass()"""
  return _coin.SoShaderParameterArray2f_initClass()

class SoShaderParameterArray2i(SoUniformShaderParameter):
    """Proxy of C++ SoShaderParameterArray2i class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterArray2i_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoShaderParameterArray2i_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameterArray2i_value_get, _coin.SoShaderParameterArray2i_value_set)
    def __init__(self): 
        """__init__(self) -> SoShaderParameterArray2i"""
        this = _coin.new_SoShaderParameterArray2i()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoShaderParameterArray2i_initClass()

    initClass = staticmethod(initClass)
    def updateParameter(self, *args):
        """updateParameter(self, SoGLShaderObject shaderObject)"""
        return _coin.SoShaderParameterArray2i_updateParameter(self, *args)

SoShaderParameterArray2i_swigregister = _coin.SoShaderParameterArray2i_swigregister
SoShaderParameterArray2i_swigregister(SoShaderParameterArray2i)

def SoShaderParameterArray2i_getClassTypeId():
  """SoShaderParameterArray2i_getClassTypeId() -> SoType"""
  return _coin.SoShaderParameterArray2i_getClassTypeId()

def SoShaderParameterArray2i_initClass():
  """SoShaderParameterArray2i_initClass()"""
  return _coin.SoShaderParameterArray2i_initClass()

class SoShaderParameterArray3f(SoUniformShaderParameter):
    """Proxy of C++ SoShaderParameterArray3f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterArray3f_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoShaderParameterArray3f_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameterArray3f_value_get, _coin.SoShaderParameterArray3f_value_set)
    def __init__(self): 
        """__init__(self) -> SoShaderParameterArray3f"""
        this = _coin.new_SoShaderParameterArray3f()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoShaderParameterArray3f_initClass()

    initClass = staticmethod(initClass)
    def updateParameter(self, *args):
        """updateParameter(self, SoGLShaderObject shaderObject)"""
        return _coin.SoShaderParameterArray3f_updateParameter(self, *args)

SoShaderParameterArray3f_swigregister = _coin.SoShaderParameterArray3f_swigregister
SoShaderParameterArray3f_swigregister(SoShaderParameterArray3f)

def SoShaderParameterArray3f_getClassTypeId():
  """SoShaderParameterArray3f_getClassTypeId() -> SoType"""
  return _coin.SoShaderParameterArray3f_getClassTypeId()

def SoShaderParameterArray3f_initClass():
  """SoShaderParameterArray3f_initClass()"""
  return _coin.SoShaderParameterArray3f_initClass()

class SoShaderParameterArray3i(SoUniformShaderParameter):
    """Proxy of C++ SoShaderParameterArray3i class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterArray3i_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoShaderParameterArray3i_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameterArray3i_value_get, _coin.SoShaderParameterArray3i_value_set)
    def __init__(self): 
        """__init__(self) -> SoShaderParameterArray3i"""
        this = _coin.new_SoShaderParameterArray3i()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoShaderParameterArray3i_initClass()

    initClass = staticmethod(initClass)
    def updateParameter(self, *args):
        """updateParameter(self, SoGLShaderObject shaderObject)"""
        return _coin.SoShaderParameterArray3i_updateParameter(self, *args)

SoShaderParameterArray3i_swigregister = _coin.SoShaderParameterArray3i_swigregister
SoShaderParameterArray3i_swigregister(SoShaderParameterArray3i)

def SoShaderParameterArray3i_getClassTypeId():
  """SoShaderParameterArray3i_getClassTypeId() -> SoType"""
  return _coin.SoShaderParameterArray3i_getClassTypeId()

def SoShaderParameterArray3i_initClass():
  """SoShaderParameterArray3i_initClass()"""
  return _coin.SoShaderParameterArray3i_initClass()

class SoShaderParameterArray4f(SoUniformShaderParameter):
    """Proxy of C++ SoShaderParameterArray4f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterArray4f_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoShaderParameterArray4f_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameterArray4f_value_get, _coin.SoShaderParameterArray4f_value_set)
    def __init__(self): 
        """__init__(self) -> SoShaderParameterArray4f"""
        this = _coin.new_SoShaderParameterArray4f()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoShaderParameterArray4f_initClass()

    initClass = staticmethod(initClass)
    def updateParameter(self, *args):
        """updateParameter(self, SoGLShaderObject shaderObject)"""
        return _coin.SoShaderParameterArray4f_updateParameter(self, *args)

SoShaderParameterArray4f_swigregister = _coin.SoShaderParameterArray4f_swigregister
SoShaderParameterArray4f_swigregister(SoShaderParameterArray4f)

def SoShaderParameterArray4f_getClassTypeId():
  """SoShaderParameterArray4f_getClassTypeId() -> SoType"""
  return _coin.SoShaderParameterArray4f_getClassTypeId()

def SoShaderParameterArray4f_initClass():
  """SoShaderParameterArray4f_initClass()"""
  return _coin.SoShaderParameterArray4f_initClass()

class SoShaderParameterArray4i(SoUniformShaderParameter):
    """Proxy of C++ SoShaderParameterArray4i class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterArray4i_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoShaderParameterArray4i_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameterArray4i_value_get, _coin.SoShaderParameterArray4i_value_set)
    def __init__(self): 
        """__init__(self) -> SoShaderParameterArray4i"""
        this = _coin.new_SoShaderParameterArray4i()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoShaderParameterArray4i_initClass()

    initClass = staticmethod(initClass)
    def updateParameter(self, *args):
        """updateParameter(self, SoGLShaderObject shaderObject)"""
        return _coin.SoShaderParameterArray4i_updateParameter(self, *args)

SoShaderParameterArray4i_swigregister = _coin.SoShaderParameterArray4i_swigregister
SoShaderParameterArray4i_swigregister(SoShaderParameterArray4i)

def SoShaderParameterArray4i_getClassTypeId():
  """SoShaderParameterArray4i_getClassTypeId() -> SoType"""
  return _coin.SoShaderParameterArray4i_getClassTypeId()

def SoShaderParameterArray4i_initClass():
  """SoShaderParameterArray4i_initClass()"""
  return _coin.SoShaderParameterArray4i_initClass()

class SoShaderParameterMatrix(SoUniformShaderParameter):
    """Proxy of C++ SoShaderParameterMatrix class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterMatrix_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoShaderParameterMatrix_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameterMatrix_value_get, _coin.SoShaderParameterMatrix_value_set)
    def __init__(self): 
        """__init__(self) -> SoShaderParameterMatrix"""
        this = _coin.new_SoShaderParameterMatrix()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoShaderParameterMatrix_initClass()

    initClass = staticmethod(initClass)
    def updateParameter(self, *args):
        """updateParameter(self, SoGLShaderObject shaderObject)"""
        return _coin.SoShaderParameterMatrix_updateParameter(self, *args)

SoShaderParameterMatrix_swigregister = _coin.SoShaderParameterMatrix_swigregister
SoShaderParameterMatrix_swigregister(SoShaderParameterMatrix)

def SoShaderParameterMatrix_getClassTypeId():
  """SoShaderParameterMatrix_getClassTypeId() -> SoType"""
  return _coin.SoShaderParameterMatrix_getClassTypeId()

def SoShaderParameterMatrix_initClass():
  """SoShaderParameterMatrix_initClass()"""
  return _coin.SoShaderParameterMatrix_initClass()

class SoShaderParameterMatrixArray(SoUniformShaderParameter):
    """Proxy of C++ SoShaderParameterMatrixArray class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterMatrixArray_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoShaderParameterMatrixArray_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameterMatrixArray_value_get, _coin.SoShaderParameterMatrixArray_value_set)
    def __init__(self): 
        """__init__(self) -> SoShaderParameterMatrixArray"""
        this = _coin.new_SoShaderParameterMatrixArray()
        try: self.this.append(this)
        except: self.this = this
    def initClass():
        """initClass()"""
        return _coin.SoShaderParameterMatrixArray_initClass()

    initClass = staticmethod(initClass)
    def updateParameter(self, *args):
        """updateParameter(self, SoGLShaderObject shaderObject)"""
        return _coin.SoShaderParameterMatrixArray_updateParameter(self, *args)

SoShaderParameterMatrixArray_swigregister = _coin.SoShaderParameterMatrixArray_swigregister
SoShaderParameterMatrixArray_swigregister(SoShaderParameterMatrixArray)

def SoShaderParameterMatrixArray_getClassTypeId():
  """SoShaderParameterMatrixArray_getClassTypeId() -> SoType"""
  return _coin.SoShaderParameterMatrixArray_getClassTypeId()

def SoShaderParameterMatrixArray_initClass():
  """SoShaderParameterMatrixArray_initClass()"""
  return _coin.SoShaderParameterMatrixArray_initClass()

class SoShaderStateMatrixParameter(SoUniformShaderParameter):
    """Proxy of C++ SoShaderStateMatrixParameter class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShaderStateMatrixParameter_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoShaderStateMatrixParameter_getTypeId(self)

    MODELVIEW = _coin.SoShaderStateMatrixParameter_MODELVIEW
    PROJECTION = _coin.SoShaderStateMatrixParameter_PROJECTION
    TEXTURE = _coin.SoShaderStateMatrixParameter_TEXTURE
    MODELVIEW_PROJECTION = _coin.SoShaderStateMatrixParameter_MODELVIEW_PROJECTION
    IDENTITY = _coin.SoShaderStateMatrixParameter_IDENTITY
    TRANSPOSE = _coin.SoShaderStateMatrixParameter_TRANSPOSE
    INVERSE = _coin.SoShaderStateMatrixParameter_INVERSE
    INVERSE_TRANSPOSE = _coin.SoShaderStateMatrixParameter_INVERSE_TRANSPOSE
    matrixType = _swig_property(_coin.SoShaderStateMatrixParameter_matrixType_get, _coin.SoShaderStateMatrixParameter_matrixType_set)
    matrixTransform = _swig_property(_coin.SoShaderStateMatrixParameter_matrixTransform_get, _coin.SoShaderStateMatrixParameter_matrixTransform_set)
    def __init__(self): 
        """__init__(self) -> SoShaderStateMatrixParameter"""
        this = _coin.new_SoShaderStateMatrixParameter()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoShaderStateMatrixParameter
    __del__ = lambda self : None;
    def initClass():
        """initClass()"""
        return _coin.SoShaderStateMatrixParameter_initClass()

    initClass = staticmethod(initClass)
    def updateParameter(self, *args):
        """updateParameter(self, SoGLShaderObject shaderObject)"""
        return _coin.SoShaderStateMatrixParameter_updateParameter(self, *args)

SoShaderStateMatrixParameter_swigregister = _coin.SoShaderStateMatrixParameter_swigregister
SoShaderStateMatrixParameter_swigregister(SoShaderStateMatrixParameter)

def SoShaderStateMatrixParameter_getClassTypeId():
  """SoShaderStateMatrixParameter_getClassTypeId() -> SoType"""
  return _coin.SoShaderStateMatrixParameter_getClassTypeId()

def SoShaderStateMatrixParameter_initClass():
  """SoShaderStateMatrixParameter_initClass()"""
  return _coin.SoShaderStateMatrixParameter_initClass()

class SoShaderProgram(SoNode):
    """Proxy of C++ SoShaderProgram class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoShaderProgram_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoShaderProgram_getTypeId(self)

    shaderObject = _swig_property(_coin.SoShaderProgram_shaderObject_get, _coin.SoShaderProgram_shaderObject_set)
    def __init__(self): 
        """__init__(self) -> SoShaderProgram"""
        this = _coin.new_SoShaderProgram()
        try: self.this.append(this)
        except: self.this = this
    def setEnableCallback(self, *args):
        """setEnableCallback(self, SoShaderProgramEnableCB cb, void closure)"""
        return _coin.SoShaderProgram_setEnableCallback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoShaderProgram_GLRender(self, *args)

    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoShaderProgram_search(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoShaderProgram_initClass()

    initClass = staticmethod(initClass)
SoShaderProgram_swigregister = _coin.SoShaderProgram_swigregister
SoShaderProgram_swigregister(SoShaderProgram)

def SoShaderProgram_getClassTypeId():
  """SoShaderProgram_getClassTypeId() -> SoType"""
  return _coin.SoShaderProgram_getClassTypeId()

def SoShaderProgram_initClass():
  """SoShaderProgram_initClass()"""
  return _coin.SoShaderProgram_initClass()

class SoFragmentShader(SoShaderObject):
    """Proxy of C++ SoFragmentShader class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoFragmentShader_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoFragmentShader_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoFragmentShader_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoFragmentShader"""
        this = _coin.new_SoFragmentShader()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoFragmentShader
    __del__ = lambda self : None;
    def isSupported(*args):
        """isSupported(SourceType sourceType) -> SbBool"""
        return _coin.SoFragmentShader_isSupported(*args)

    isSupported = staticmethod(isSupported)
SoFragmentShader_swigregister = _coin.SoFragmentShader_swigregister
SoFragmentShader_swigregister(SoFragmentShader)

def SoFragmentShader_getClassTypeId():
  """SoFragmentShader_getClassTypeId() -> SoType"""
  return _coin.SoFragmentShader_getClassTypeId()

def SoFragmentShader_initClass():
  """SoFragmentShader_initClass()"""
  return _coin.SoFragmentShader_initClass()

def SoFragmentShader_isSupported(*args):
  """SoFragmentShader_isSupported(SourceType sourceType) -> SbBool"""
  return _coin.SoFragmentShader_isSupported(*args)

class SoVertexShader(SoShaderObject):
    """Proxy of C++ SoVertexShader class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVertexShader_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVertexShader_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVertexShader_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVertexShader"""
        this = _coin.new_SoVertexShader()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoVertexShader
    __del__ = lambda self : None;
    def isSupported(*args):
        """isSupported(SourceType sourceType) -> SbBool"""
        return _coin.SoVertexShader_isSupported(*args)

    isSupported = staticmethod(isSupported)
SoVertexShader_swigregister = _coin.SoVertexShader_swigregister
SoVertexShader_swigregister(SoVertexShader)

def SoVertexShader_getClassTypeId():
  """SoVertexShader_getClassTypeId() -> SoType"""
  return _coin.SoVertexShader_getClassTypeId()

def SoVertexShader_initClass():
  """SoVertexShader_initClass()"""
  return _coin.SoVertexShader_initClass()

def SoVertexShader_isSupported(*args):
  """SoVertexShader_isSupported(SourceType sourceType) -> SbBool"""
  return _coin.SoVertexShader_isSupported(*args)

class SoTextureCoordinateNormalMap(SoTextureCoordinateFunction):
    """Proxy of C++ SoTextureCoordinateNormalMap class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateNormalMap_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTextureCoordinateNormalMap_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTextureCoordinateNormalMap_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTextureCoordinateNormalMap"""
        this = _coin.new_SoTextureCoordinateNormalMap()
        try: self.this.append(this)
        except: self.this = this
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoTextureCoordinateNormalMap_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateNormalMap_GLRender(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoTextureCoordinateNormalMap_pick(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateNormalMap_callback(self, *args)

SoTextureCoordinateNormalMap_swigregister = _coin.SoTextureCoordinateNormalMap_swigregister
SoTextureCoordinateNormalMap_swigregister(SoTextureCoordinateNormalMap)

def SoTextureCoordinateNormalMap_getClassTypeId():
  """SoTextureCoordinateNormalMap_getClassTypeId() -> SoType"""
  return _coin.SoTextureCoordinateNormalMap_getClassTypeId()

def SoTextureCoordinateNormalMap_initClass():
  """SoTextureCoordinateNormalMap_initClass()"""
  return _coin.SoTextureCoordinateNormalMap_initClass()

class SoTextureCoordinateReflectionMap(SoTextureCoordinateFunction):
    """Proxy of C++ SoTextureCoordinateReflectionMap class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateReflectionMap_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTextureCoordinateReflectionMap_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTextureCoordinateReflectionMap_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTextureCoordinateReflectionMap"""
        this = _coin.new_SoTextureCoordinateReflectionMap()
        try: self.this.append(this)
        except: self.this = this
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoTextureCoordinateReflectionMap_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateReflectionMap_GLRender(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoTextureCoordinateReflectionMap_pick(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateReflectionMap_callback(self, *args)

SoTextureCoordinateReflectionMap_swigregister = _coin.SoTextureCoordinateReflectionMap_swigregister
SoTextureCoordinateReflectionMap_swigregister(SoTextureCoordinateReflectionMap)

def SoTextureCoordinateReflectionMap_getClassTypeId():
  """SoTextureCoordinateReflectionMap_getClassTypeId() -> SoType"""
  return _coin.SoTextureCoordinateReflectionMap_getClassTypeId()

def SoTextureCoordinateReflectionMap_initClass():
  """SoTextureCoordinateReflectionMap_initClass()"""
  return _coin.SoTextureCoordinateReflectionMap_initClass()

class SoTextureCoordinateObject(SoTextureCoordinateFunction):
    """Proxy of C++ SoTextureCoordinateObject class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateObject_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTextureCoordinateObject_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTextureCoordinateObject_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTextureCoordinateObject"""
        this = _coin.new_SoTextureCoordinateObject()
        try: self.this.append(this)
        except: self.this = this
    factorS = _swig_property(_coin.SoTextureCoordinateObject_factorS_get, _coin.SoTextureCoordinateObject_factorS_set)
    factorT = _swig_property(_coin.SoTextureCoordinateObject_factorT_get, _coin.SoTextureCoordinateObject_factorT_set)
    factorR = _swig_property(_coin.SoTextureCoordinateObject_factorR_get, _coin.SoTextureCoordinateObject_factorR_set)
    factorQ = _swig_property(_coin.SoTextureCoordinateObject_factorQ_get, _coin.SoTextureCoordinateObject_factorQ_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoTextureCoordinateObject_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateObject_GLRender(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoTextureCoordinateObject_pick(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateObject_callback(self, *args)

SoTextureCoordinateObject_swigregister = _coin.SoTextureCoordinateObject_swigregister
SoTextureCoordinateObject_swigregister(SoTextureCoordinateObject)

def SoTextureCoordinateObject_getClassTypeId():
  """SoTextureCoordinateObject_getClassTypeId() -> SoType"""
  return _coin.SoTextureCoordinateObject_getClassTypeId()

def SoTextureCoordinateObject_initClass():
  """SoTextureCoordinateObject_initClass()"""
  return _coin.SoTextureCoordinateObject_initClass()

class SoTextureScalePolicy(SoNode):
    """Proxy of C++ SoTextureScalePolicy class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextureScalePolicy_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTextureScalePolicy_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTextureScalePolicy_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTextureScalePolicy"""
        this = _coin.new_SoTextureScalePolicy()
        try: self.this.append(this)
        except: self.this = this
    USE_TEXTURE_QUALITY = _coin.SoTextureScalePolicy_USE_TEXTURE_QUALITY
    SCALE_DOWN = _coin.SoTextureScalePolicy_SCALE_DOWN
    SCALE_UP = _coin.SoTextureScalePolicy_SCALE_UP
    FRACTURE = _coin.SoTextureScalePolicy_FRACTURE
    policy = _swig_property(_coin.SoTextureScalePolicy_policy_get, _coin.SoTextureScalePolicy_policy_set)
    quality = _swig_property(_coin.SoTextureScalePolicy_quality_get, _coin.SoTextureScalePolicy_quality_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoTextureScalePolicy_GLRender(self, *args)

SoTextureScalePolicy_swigregister = _coin.SoTextureScalePolicy_swigregister
SoTextureScalePolicy_swigregister(SoTextureScalePolicy)

def SoTextureScalePolicy_getClassTypeId():
  """SoTextureScalePolicy_getClassTypeId() -> SoType"""
  return _coin.SoTextureScalePolicy_getClassTypeId()

def SoTextureScalePolicy_initClass():
  """SoTextureScalePolicy_initClass()"""
  return _coin.SoTextureScalePolicy_initClass()

class SoTextureUnit(SoNode):
    """Proxy of C++ SoTextureUnit class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextureUnit_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTextureUnit_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTextureUnit_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTextureUnit"""
        this = _coin.new_SoTextureUnit()
        try: self.this.append(this)
        except: self.this = this
    BUMP_MAPPING = _coin.SoTextureUnit_BUMP_MAPPING
    IMAGE_MAPPING = _coin.SoTextureUnit_IMAGE_MAPPING
    unit = _swig_property(_coin.SoTextureUnit_unit_get, _coin.SoTextureUnit_unit_set)
    mappingMethod = _swig_property(_coin.SoTextureUnit_mappingMethod_get, _coin.SoTextureUnit_mappingMethod_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoTextureUnit_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoTextureUnit_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoTextureUnit_GLRender(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoTextureUnit_pick(self, *args)

    def getMaxTextureUnit():
        """getMaxTextureUnit() -> uint32_t"""
        return _coin.SoTextureUnit_getMaxTextureUnit()

    getMaxTextureUnit = staticmethod(getMaxTextureUnit)
SoTextureUnit_swigregister = _coin.SoTextureUnit_swigregister
SoTextureUnit_swigregister(SoTextureUnit)

def SoTextureUnit_getClassTypeId():
  """SoTextureUnit_getClassTypeId() -> SoType"""
  return _coin.SoTextureUnit_getClassTypeId()

def SoTextureUnit_initClass():
  """SoTextureUnit_initClass()"""
  return _coin.SoTextureUnit_initClass()

def SoTextureUnit_getMaxTextureUnit():
  """SoTextureUnit_getMaxTextureUnit() -> uint32_t"""
  return _coin.SoTextureUnit_getMaxTextureUnit()

class SoTextureCombine(SoNode):
    """Proxy of C++ SoTextureCombine class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoTextureCombine_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoTextureCombine_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoTextureCombine_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoTextureCombine"""
        this = _coin.new_SoTextureCombine()
        try: self.this.append(this)
        except: self.this = this
    PRIMARY_COLOR = _coin.SoTextureCombine_PRIMARY_COLOR
    TEXTURE = _coin.SoTextureCombine_TEXTURE
    CONSTANT = _coin.SoTextureCombine_CONSTANT
    PREVIOUS = _coin.SoTextureCombine_PREVIOUS
    SRC_COLOR = _coin.SoTextureCombine_SRC_COLOR
    ONE_MINUS_SRC_COLOR = _coin.SoTextureCombine_ONE_MINUS_SRC_COLOR
    SRC_ALPHA = _coin.SoTextureCombine_SRC_ALPHA
    ONE_MINUS_SRC_ALPHA = _coin.SoTextureCombine_ONE_MINUS_SRC_ALPHA
    REPLACE = _coin.SoTextureCombine_REPLACE
    MODULATE = _coin.SoTextureCombine_MODULATE
    ADD = _coin.SoTextureCombine_ADD
    ADD_SIGNED = _coin.SoTextureCombine_ADD_SIGNED
    SUBTRACT = _coin.SoTextureCombine_SUBTRACT
    INTERPOLATE = _coin.SoTextureCombine_INTERPOLATE
    DOT3_RGB = _coin.SoTextureCombine_DOT3_RGB
    DOT3_RGBA = _coin.SoTextureCombine_DOT3_RGBA
    rgbSource = _swig_property(_coin.SoTextureCombine_rgbSource_get, _coin.SoTextureCombine_rgbSource_set)
    alphaSource = _swig_property(_coin.SoTextureCombine_alphaSource_get, _coin.SoTextureCombine_alphaSource_set)
    rgbOperand = _swig_property(_coin.SoTextureCombine_rgbOperand_get, _coin.SoTextureCombine_rgbOperand_set)
    alphaOperand = _swig_property(_coin.SoTextureCombine_alphaOperand_get, _coin.SoTextureCombine_alphaOperand_set)
    rgbOperation = _swig_property(_coin.SoTextureCombine_rgbOperation_get, _coin.SoTextureCombine_rgbOperation_set)
    alphaOperation = _swig_property(_coin.SoTextureCombine_alphaOperation_get, _coin.SoTextureCombine_alphaOperation_set)
    rgbScale = _swig_property(_coin.SoTextureCombine_rgbScale_get, _coin.SoTextureCombine_rgbScale_set)
    alphaScale = _swig_property(_coin.SoTextureCombine_alphaScale_get, _coin.SoTextureCombine_alphaScale_set)
    constantColor = _swig_property(_coin.SoTextureCombine_constantColor_get, _coin.SoTextureCombine_constantColor_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoTextureCombine_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoTextureCombine_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoTextureCombine_GLRender(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoTextureCombine_pick(self, *args)

SoTextureCombine_swigregister = _coin.SoTextureCombine_swigregister
SoTextureCombine_swigregister(SoTextureCombine)

def SoTextureCombine_getClassTypeId():
  """SoTextureCombine_getClassTypeId() -> SoType"""
  return _coin.SoTextureCombine_getClassTypeId()

def SoTextureCombine_initClass():
  """SoTextureCombine_initClass()"""
  return _coin.SoTextureCombine_initClass()

class SoSceneTexture2(SoNode):
    """Proxy of C++ SoSceneTexture2 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSceneTexture2_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSceneTexture2_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoSceneTexture2_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoSceneTexture2"""
        this = _coin.new_SoSceneTexture2()
        try: self.this.append(this)
        except: self.this = this
    MODULATE = _coin.SoSceneTexture2_MODULATE
    DECAL = _coin.SoSceneTexture2_DECAL
    BLEND = _coin.SoSceneTexture2_BLEND
    REPLACE = _coin.SoSceneTexture2_REPLACE
    REPEAT = _coin.SoSceneTexture2_REPEAT
    CLAMP = _coin.SoSceneTexture2_CLAMP
    CLAMP_TO_BORDER = _coin.SoSceneTexture2_CLAMP_TO_BORDER
    NONE = _coin.SoSceneTexture2_NONE
    ALPHA_BLEND = _coin.SoSceneTexture2_ALPHA_BLEND
    ALPHA_TEST = _coin.SoSceneTexture2_ALPHA_TEST
    DEPTH = _coin.SoSceneTexture2_DEPTH
    RGBA8 = _coin.SoSceneTexture2_RGBA8
    RGBA32F = _coin.SoSceneTexture2_RGBA32F
    RGB32F = _coin.SoSceneTexture2_RGB32F
    RGBA16F = _coin.SoSceneTexture2_RGBA16F
    RGB16F = _coin.SoSceneTexture2_RGB16F
    R3_G3_B2 = _coin.SoSceneTexture2_R3_G3_B2
    RGB = _coin.SoSceneTexture2_RGB
    RGB4 = _coin.SoSceneTexture2_RGB4
    RGB5 = _coin.SoSceneTexture2_RGB5
    RGB8 = _coin.SoSceneTexture2_RGB8
    RGB10 = _coin.SoSceneTexture2_RGB10
    RGB12 = _coin.SoSceneTexture2_RGB12
    RGB16 = _coin.SoSceneTexture2_RGB16
    RGBA = _coin.SoSceneTexture2_RGBA
    RGBA2 = _coin.SoSceneTexture2_RGBA2
    RGBA4 = _coin.SoSceneTexture2_RGBA4
    RGB5_A1 = _coin.SoSceneTexture2_RGB5_A1
    RGB10_A2 = _coin.SoSceneTexture2_RGB10_A2
    RGBA12 = _coin.SoSceneTexture2_RGBA12
    RGBA16 = _coin.SoSceneTexture2_RGBA16
    wrapS = _swig_property(_coin.SoSceneTexture2_wrapS_get, _coin.SoSceneTexture2_wrapS_set)
    wrapT = _swig_property(_coin.SoSceneTexture2_wrapT_get, _coin.SoSceneTexture2_wrapT_set)
    model = _swig_property(_coin.SoSceneTexture2_model_get, _coin.SoSceneTexture2_model_set)
    blendColor = _swig_property(_coin.SoSceneTexture2_blendColor_get, _coin.SoSceneTexture2_blendColor_set)
    backgroundColor = _swig_property(_coin.SoSceneTexture2_backgroundColor_get, _coin.SoSceneTexture2_backgroundColor_set)
    size = _swig_property(_coin.SoSceneTexture2_size_get, _coin.SoSceneTexture2_size_set)
    scene = _swig_property(_coin.SoSceneTexture2_scene_get, _coin.SoSceneTexture2_scene_set)
    sceneTransparencyType = _swig_property(_coin.SoSceneTexture2_sceneTransparencyType_get, _coin.SoSceneTexture2_sceneTransparencyType_set)
    transparencyFunction = _swig_property(_coin.SoSceneTexture2_transparencyFunction_get, _coin.SoSceneTexture2_transparencyFunction_set)
    type = _swig_property(_coin.SoSceneTexture2_type_get, _coin.SoSceneTexture2_type_set)
    def notify(self, *args):
        """notify(self, SoNotList list)"""
        return _coin.SoSceneTexture2_notify(self, *args)

    def write(self, *args):
        """write(self, SoWriteAction action)"""
        return _coin.SoSceneTexture2_write(self, *args)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoSceneTexture2_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoSceneTexture2_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoSceneTexture2_callback(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoSceneTexture2_rayPick(self, *args)

SoSceneTexture2_swigregister = _coin.SoSceneTexture2_swigregister
SoSceneTexture2_swigregister(SoSceneTexture2)

def SoSceneTexture2_getClassTypeId():
  """SoSceneTexture2_getClassTypeId() -> SoType"""
  return _coin.SoSceneTexture2_getClassTypeId()

def SoSceneTexture2_initClass():
  """SoSceneTexture2_initClass()"""
  return _coin.SoSceneTexture2_initClass()

class SoSceneTextureCubeMap(SoNode):
    """Proxy of C++ SoSceneTextureCubeMap class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoSceneTextureCubeMap_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoSceneTextureCubeMap_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoSceneTextureCubeMap_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoSceneTextureCubeMap"""
        this = _coin.new_SoSceneTextureCubeMap()
        try: self.this.append(this)
        except: self.this = this
    MODULATE = _coin.SoSceneTextureCubeMap_MODULATE
    DECAL = _coin.SoSceneTextureCubeMap_DECAL
    BLEND = _coin.SoSceneTextureCubeMap_BLEND
    REPLACE = _coin.SoSceneTextureCubeMap_REPLACE
    REPEAT = _coin.SoSceneTextureCubeMap_REPEAT
    CLAMP = _coin.SoSceneTextureCubeMap_CLAMP
    NONE = _coin.SoSceneTextureCubeMap_NONE
    ALPHA_BLEND = _coin.SoSceneTextureCubeMap_ALPHA_BLEND
    ALPHA_TEST = _coin.SoSceneTextureCubeMap_ALPHA_TEST
    size = _swig_property(_coin.SoSceneTextureCubeMap_size_get, _coin.SoSceneTextureCubeMap_size_set)
    scene = _swig_property(_coin.SoSceneTextureCubeMap_scene_get, _coin.SoSceneTextureCubeMap_scene_set)
    wrapS = _swig_property(_coin.SoSceneTextureCubeMap_wrapS_get, _coin.SoSceneTextureCubeMap_wrapS_set)
    wrapT = _swig_property(_coin.SoSceneTextureCubeMap_wrapT_get, _coin.SoSceneTextureCubeMap_wrapT_set)
    wrapR = _swig_property(_coin.SoSceneTextureCubeMap_wrapR_get, _coin.SoSceneTextureCubeMap_wrapR_set)
    model = _swig_property(_coin.SoSceneTextureCubeMap_model_get, _coin.SoSceneTextureCubeMap_model_set)
    backgroundColor = _swig_property(_coin.SoSceneTextureCubeMap_backgroundColor_get, _coin.SoSceneTextureCubeMap_backgroundColor_set)
    transparencyFunction = _swig_property(_coin.SoSceneTextureCubeMap_transparencyFunction_get, _coin.SoSceneTextureCubeMap_transparencyFunction_set)
    blendColor = _swig_property(_coin.SoSceneTextureCubeMap_blendColor_get, _coin.SoSceneTextureCubeMap_blendColor_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoSceneTextureCubeMap_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoSceneTextureCubeMap_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoSceneTextureCubeMap_callback(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoSceneTextureCubeMap_rayPick(self, *args)

SoSceneTextureCubeMap_swigregister = _coin.SoSceneTextureCubeMap_swigregister
SoSceneTextureCubeMap_swigregister(SoSceneTextureCubeMap)

def SoSceneTextureCubeMap_getClassTypeId():
  """SoSceneTextureCubeMap_getClassTypeId() -> SoType"""
  return _coin.SoSceneTextureCubeMap_getClassTypeId()

def SoSceneTextureCubeMap_initClass():
  """SoSceneTextureCubeMap_initClass()"""
  return _coin.SoSceneTextureCubeMap_initClass()

class SoCacheHintElement(SoElement):
    """Proxy of C++ SoCacheHintElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoCacheHintElement_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getClassStackIndex():
        """getClassStackIndex() -> int"""
        return _coin.SoCacheHintElement_getClassStackIndex()

    getClassStackIndex = staticmethod(getClassStackIndex)
    def createInstance():
        """createInstance() -> void"""
        return _coin.SoCacheHintElement_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoCacheHintElement_initClass()

    initClass = staticmethod(initClass)
    def init(self, *args):
        """init(self, SoState state)"""
        return _coin.SoCacheHintElement_init(self, *args)

    def push(self, *args):
        """push(self, SoState state)"""
        return _coin.SoCacheHintElement_push(self, *args)

    def pop(self, *args):
        """pop(self, SoState state, SoElement prevtopelement)"""
        return _coin.SoCacheHintElement_pop(self, *args)

    def matches(self, *args):
        """matches(self, SoElement element) -> SbBool"""
        return _coin.SoCacheHintElement_matches(self, *args)

    def copyMatchInfo(self):
        """copyMatchInfo(self) -> SoElement"""
        return _coin.SoCacheHintElement_copyMatchInfo(self)

    def set(*args):
        """set(SoState state, SoNode node, float memvalue, float gfxvalue)"""
        return _coin.SoCacheHintElement_set(*args)

    set = staticmethod(set)
    def get(*args):
        """get(SoState state, float memvalue, float gfxvalue)"""
        return _coin.SoCacheHintElement_get(*args)

    get = staticmethod(get)
SoCacheHintElement_swigregister = _coin.SoCacheHintElement_swigregister
SoCacheHintElement_swigregister(SoCacheHintElement)

def SoCacheHintElement_getClassTypeId():
  """SoCacheHintElement_getClassTypeId() -> SoType"""
  return _coin.SoCacheHintElement_getClassTypeId()

def SoCacheHintElement_getClassStackIndex():
  """SoCacheHintElement_getClassStackIndex() -> int"""
  return _coin.SoCacheHintElement_getClassStackIndex()

def SoCacheHintElement_createInstance():
  """SoCacheHintElement_createInstance() -> void"""
  return _coin.SoCacheHintElement_createInstance()

def SoCacheHintElement_initClass():
  """SoCacheHintElement_initClass()"""
  return _coin.SoCacheHintElement_initClass()

def SoCacheHintElement_set(*args):
  """SoCacheHintElement_set(SoState state, SoNode node, float memvalue, float gfxvalue)"""
  return _coin.SoCacheHintElement_set(*args)

def SoCacheHintElement_get(*args):
  """SoCacheHintElement_get(SoState state, float memvalue, float gfxvalue)"""
  return _coin.SoCacheHintElement_get(*args)

class SoCacheHint(SoNode):
    """Proxy of C++ SoCacheHint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoCacheHint_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoCacheHint_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoCacheHint_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoCacheHint"""
        this = _coin.new_SoCacheHint()
        try: self.this.append(this)
        except: self.this = this
    memValue = _swig_property(_coin.SoCacheHint_memValue_get, _coin.SoCacheHint_memValue_set)
    gfxValue = _swig_property(_coin.SoCacheHint_gfxValue_get, _coin.SoCacheHint_gfxValue_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoCacheHint_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoCacheHint_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoCacheHint_callback(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoCacheHint_getBoundingBox(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoCacheHint_pick(self, *args)

SoCacheHint_swigregister = _coin.SoCacheHint_swigregister
SoCacheHint_swigregister(SoCacheHint)

def SoCacheHint_getClassTypeId():
  """SoCacheHint_getClassTypeId() -> SoType"""
  return _coin.SoCacheHint_getClassTypeId()

def SoCacheHint_initClass():
  """SoCacheHint_initClass()"""
  return _coin.SoCacheHint_initClass()

class SoDepthBuffer(SoNode):
    """Proxy of C++ SoDepthBuffer class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoDepthBuffer_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoDepthBuffer_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoDepthBuffer_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoDepthBuffer"""
        this = _coin.new_SoDepthBuffer()
        try: self.this.append(this)
        except: self.this = this
    NEVER = _coin.SoDepthBuffer_NEVER
    ALWAYS = _coin.SoDepthBuffer_ALWAYS
    LESS = _coin.SoDepthBuffer_LESS
    LEQUAL = _coin.SoDepthBuffer_LEQUAL
    EQUAL = _coin.SoDepthBuffer_EQUAL
    GEQUAL = _coin.SoDepthBuffer_GEQUAL
    GREATER = _coin.SoDepthBuffer_GREATER
    NOTEQUAL = _coin.SoDepthBuffer_NOTEQUAL
    test = _swig_property(_coin.SoDepthBuffer_test_get, _coin.SoDepthBuffer_test_set)
    write = _swig_property(_coin.SoDepthBuffer_write_get, _coin.SoDepthBuffer_write_set)
    function = _swig_property(_coin.SoDepthBuffer_function_get, _coin.SoDepthBuffer_function_set)
    range = _swig_property(_coin.SoDepthBuffer_range_get, _coin.SoDepthBuffer_range_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoDepthBuffer_GLRender(self, *args)

SoDepthBuffer_swigregister = _coin.SoDepthBuffer_swigregister
SoDepthBuffer_swigregister(SoDepthBuffer)

def SoDepthBuffer_getClassTypeId():
  """SoDepthBuffer_getClassTypeId() -> SoType"""
  return _coin.SoDepthBuffer_getClassTypeId()

def SoDepthBuffer_initClass():
  """SoDepthBuffer_initClass()"""
  return _coin.SoDepthBuffer_initClass()

class SbLine(object):
    """Proxy of C++ SbLine class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbLine
        __init__(self, SbVec3f origin, SbVec3f point) -> SbLine
        """
        this = _coin.new_SbLine(*args)
        try: self.this.append(this)
        except: self.this = this
    def setValue(self, *args):
        """setValue(self, SbVec3f origin, SbVec3f point)"""
        return _coin.SbLine_setValue(self, *args)

    def getClosestPoints(self, *args):
        """getClosestPoints(self, SbLine line2, SbVec3f ptOnThis, SbVec3f ptOnLine2) -> SbBool"""
        return _coin.SbLine_getClosestPoints(self, *args)

    def getClosestPoint(self, *args):
        """getClosestPoint(self, SbVec3f point) -> SbVec3f"""
        return _coin.SbLine_getClosestPoint(self, *args)

    def getPosition(self):
        """getPosition(self) -> SbVec3f"""
        return _coin.SbLine_getPosition(self)

    def getDirection(self):
        """getDirection(self) -> SbVec3f"""
        return _coin.SbLine_getDirection(self)

    def output(self, *args):
        """output(self, FILE file)"""
        return _coin.SbLine_output(self, *args)

    __swig_destroy__ = _coin.delete_SbLine
    __del__ = lambda self : None;
SbLine_swigregister = _coin.SbLine_swigregister
SbLine_swigregister(SbLine)

class SbProjector(object):
    """Proxy of C++ SbProjector class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def project(self, *args):
        """project(self, SbVec2f point) -> SbVec3f"""
        return _coin.SbProjector_project(self, *args)

    def setViewVolume(self, *args):
        """setViewVolume(self, SbViewVolume vol)"""
        return _coin.SbProjector_setViewVolume(self, *args)

    def getViewVolume(self):
        """getViewVolume(self) -> SbViewVolume"""
        return _coin.SbProjector_getViewVolume(self)

    def setWorkingSpace(self, *args):
        """setWorkingSpace(self, SbMatrix space)"""
        return _coin.SbProjector_setWorkingSpace(self, *args)

    def getWorkingSpace(self):
        """getWorkingSpace(self) -> SbMatrix"""
        return _coin.SbProjector_getWorkingSpace(self)

    def copy(self):
        """copy(self) -> SbProjector"""
        return _coin.SbProjector_copy(self)

    def tryProject(self, *args):
        """tryProject(self, SbVec2f point, float epsilon, SbVec3f result) -> SbBool"""
        return _coin.SbProjector_tryProject(self, *args)

SbProjector_swigregister = _coin.SbProjector_swigregister
SbProjector_swigregister(SbProjector)

class SbCylinder(object):
    """Proxy of C++ SbCylinder class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbCylinder
        __init__(self, SbLine a, float r) -> SbCylinder
        """
        this = _coin.new_SbCylinder(*args)
        try: self.this.append(this)
        except: self.this = this
    def setValue(self, *args):
        """setValue(self, SbLine a, float r)"""
        return _coin.SbCylinder_setValue(self, *args)

    def setAxis(self, *args):
        """setAxis(self, SbLine a)"""
        return _coin.SbCylinder_setAxis(self, *args)

    def setRadius(self, *args):
        """setRadius(self, float r)"""
        return _coin.SbCylinder_setRadius(self, *args)

    def getAxis(self):
        """getAxis(self) -> SbLine"""
        return _coin.SbCylinder_getAxis(self)

    def getRadius(self):
        """getRadius(self) -> float"""
        return _coin.SbCylinder_getRadius(self)

    def intersect(self, *args):
        """
        intersect(self, SbLine l, SbVec3f intersection) -> SbBool
        intersect(self, SbLine l, SbVec3f enter, SbVec3f exit) -> SbBool
        """
        return _coin.SbCylinder_intersect(self, *args)

    def output(self, *args):
        """output(self, FILE file)"""
        return _coin.SbCylinder_output(self, *args)

    __swig_destroy__ = _coin.delete_SbCylinder
    __del__ = lambda self : None;
SbCylinder_swigregister = _coin.SbCylinder_swigregister
SbCylinder_swigregister(SbCylinder)

class SbCylinderProjector(SbProjector):
    """Proxy of C++ SbCylinderProjector class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def project(self, *args):
        """project(self, SbVec2f point) -> SbVec3f"""
        return _coin.SbCylinderProjector_project(self, *args)

    def projectAndGetRotation(self, *args):
        """projectAndGetRotation(self, SbVec2f point, SbRotation rot) -> SbVec3f"""
        return _coin.SbCylinderProjector_projectAndGetRotation(self, *args)

    def getRotation(self, *args):
        """getRotation(self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbCylinderProjector_getRotation(self, *args)

    def setCylinder(self, *args):
        """setCylinder(self, SbCylinder cyl)"""
        return _coin.SbCylinderProjector_setCylinder(self, *args)

    def getCylinder(self):
        """getCylinder(self) -> SbCylinder"""
        return _coin.SbCylinderProjector_getCylinder(self)

    def setOrientToEye(self, *args):
        """setOrientToEye(self, SbBool orienttoeye)"""
        return _coin.SbCylinderProjector_setOrientToEye(self, *args)

    def isOrientToEye(self):
        """isOrientToEye(self) -> SbBool"""
        return _coin.SbCylinderProjector_isOrientToEye(self)

    def setFront(self, *args):
        """setFront(self, SbBool infront)"""
        return _coin.SbCylinderProjector_setFront(self, *args)

    def isFront(self):
        """isFront(self) -> SbBool"""
        return _coin.SbCylinderProjector_isFront(self)

    def isPointInFront(self, *args):
        """isPointInFront(self, SbVec3f point) -> SbBool"""
        return _coin.SbCylinderProjector_isPointInFront(self, *args)

    def setWorkingSpace(self, *args):
        """setWorkingSpace(self, SbMatrix space)"""
        return _coin.SbCylinderProjector_setWorkingSpace(self, *args)

    __swig_destroy__ = _coin.delete_SbCylinderProjector
    __del__ = lambda self : None;
SbCylinderProjector_swigregister = _coin.SbCylinderProjector_swigregister
SbCylinderProjector_swigregister(SbCylinderProjector)

class SbCylinderSectionProjector(SbCylinderProjector):
    """Proxy of C++ SbCylinderSectionProjector class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, float edgetol = 0.9, SbBool orienttoeye = 1) -> SbCylinderSectionProjector
        __init__(self, float edgetol = 0.9) -> SbCylinderSectionProjector
        __init__(self) -> SbCylinderSectionProjector
        __init__(self, SbCylinder cyl, float edgetol = 0.9, SbBool orienttoeye = 1) -> SbCylinderSectionProjector
        __init__(self, SbCylinder cyl, float edgetol = 0.9) -> SbCylinderSectionProjector
        __init__(self, SbCylinder cyl) -> SbCylinderSectionProjector
        """
        this = _coin.new_SbCylinderSectionProjector(*args)
        try: self.this.append(this)
        except: self.this = this
    def copy(self):
        """copy(self) -> SbProjector"""
        return _coin.SbCylinderSectionProjector_copy(self)

    def project(self, *args):
        """project(self, SbVec2f point) -> SbVec3f"""
        return _coin.SbCylinderSectionProjector_project(self, *args)

    def getRotation(self, *args):
        """getRotation(self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbCylinderSectionProjector_getRotation(self, *args)

    def setTolerance(self, *args):
        """setTolerance(self, float edgetol)"""
        return _coin.SbCylinderSectionProjector_setTolerance(self, *args)

    def getTolerance(self):
        """getTolerance(self) -> float"""
        return _coin.SbCylinderSectionProjector_getTolerance(self)

    def isWithinTolerance(self, *args):
        """isWithinTolerance(self, SbVec3f point) -> SbBool"""
        return _coin.SbCylinderSectionProjector_isWithinTolerance(self, *args)

    __swig_destroy__ = _coin.delete_SbCylinderSectionProjector
    __del__ = lambda self : None;
SbCylinderSectionProjector_swigregister = _coin.SbCylinderSectionProjector_swigregister
SbCylinderSectionProjector_swigregister(SbCylinderSectionProjector)

class SbCylinderPlaneProjector(SbCylinderSectionProjector):
    """Proxy of C++ SbCylinderPlaneProjector class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, float edgetol = 0.9, SbBool orienttoeye = 1) -> SbCylinderPlaneProjector
        __init__(self, float edgetol = 0.9) -> SbCylinderPlaneProjector
        __init__(self) -> SbCylinderPlaneProjector
        __init__(self, SbCylinder cyl, float edgetol = 0.9, SbBool orienttoeye = 1) -> SbCylinderPlaneProjector
        __init__(self, SbCylinder cyl, float edgetol = 0.9) -> SbCylinderPlaneProjector
        __init__(self, SbCylinder cyl) -> SbCylinderPlaneProjector
        """
        this = _coin.new_SbCylinderPlaneProjector(*args)
        try: self.this.append(this)
        except: self.this = this
    def copy(self):
        """copy(self) -> SbProjector"""
        return _coin.SbCylinderPlaneProjector_copy(self)

    def project(self, *args):
        """project(self, SbVec2f point) -> SbVec3f"""
        return _coin.SbCylinderPlaneProjector_project(self, *args)

    def getRotation(self, *args):
        """getRotation(self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbCylinderPlaneProjector_getRotation(self, *args)

    __swig_destroy__ = _coin.delete_SbCylinderPlaneProjector
    __del__ = lambda self : None;
SbCylinderPlaneProjector_swigregister = _coin.SbCylinderPlaneProjector_swigregister
SbCylinderPlaneProjector_swigregister(SbCylinderPlaneProjector)

class SbCylinderSheetProjector(SbCylinderProjector):
    """Proxy of C++ SbCylinderSheetProjector class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, SbBool orienttoeye = 1) -> SbCylinderSheetProjector
        __init__(self) -> SbCylinderSheetProjector
        __init__(self, SbCylinder cyl, SbBool orienttoeye = 1) -> SbCylinderSheetProjector
        __init__(self, SbCylinder cyl) -> SbCylinderSheetProjector
        """
        this = _coin.new_SbCylinderSheetProjector(*args)
        try: self.this.append(this)
        except: self.this = this
    def copy(self):
        """copy(self) -> SbProjector"""
        return _coin.SbCylinderSheetProjector_copy(self)

    def project(self, *args):
        """project(self, SbVec2f point) -> SbVec3f"""
        return _coin.SbCylinderSheetProjector_project(self, *args)

    def getRotation(self, *args):
        """getRotation(self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbCylinderSheetProjector_getRotation(self, *args)

    __swig_destroy__ = _coin.delete_SbCylinderSheetProjector
    __del__ = lambda self : None;
SbCylinderSheetProjector_swigregister = _coin.SbCylinderSheetProjector_swigregister
SbCylinderSheetProjector_swigregister(SbCylinderSheetProjector)

class SbLineProjector(SbProjector):
    """Proxy of C++ SbLineProjector class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SbLineProjector"""
        this = _coin.new_SbLineProjector()
        try: self.this.append(this)
        except: self.this = this
    def copy(self):
        """copy(self) -> SbProjector"""
        return _coin.SbLineProjector_copy(self)

    def project(self, *args):
        """project(self, SbVec2f point) -> SbVec3f"""
        return _coin.SbLineProjector_project(self, *args)

    def tryProject(self, *args):
        """tryProject(self, SbVec2f point, float epsilon, SbVec3f result) -> SbBool"""
        return _coin.SbLineProjector_tryProject(self, *args)

    def setLine(self, *args):
        """setLine(self, SbLine line)"""
        return _coin.SbLineProjector_setLine(self, *args)

    def getLine(self):
        """getLine(self) -> SbLine"""
        return _coin.SbLineProjector_getLine(self)

    def getVector(self, *args):
        """
        getVector(self, SbVec2f viewpos1, SbVec2f viewpos2) -> SbVec3f
        getVector(self, SbVec2f viewpos) -> SbVec3f
        """
        return _coin.SbLineProjector_getVector(self, *args)

    def setStartPosition(self, *args):
        """
        setStartPosition(self, SbVec2f viewpos)
        setStartPosition(self, SbVec3f point)
        """
        return _coin.SbLineProjector_setStartPosition(self, *args)

    __swig_destroy__ = _coin.delete_SbLineProjector
    __del__ = lambda self : None;
SbLineProjector_swigregister = _coin.SbLineProjector_swigregister
SbLineProjector_swigregister(SbLineProjector)

class SbPlaneProjector(SbProjector):
    """Proxy of C++ SbPlaneProjector class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, SbBool orient = 0) -> SbPlaneProjector
        __init__(self) -> SbPlaneProjector
        __init__(self, SbPlane plane, SbBool orient = 0) -> SbPlaneProjector
        __init__(self, SbPlane plane) -> SbPlaneProjector
        """
        this = _coin.new_SbPlaneProjector(*args)
        try: self.this.append(this)
        except: self.this = this
    def copy(self):
        """copy(self) -> SbProjector"""
        return _coin.SbPlaneProjector_copy(self)

    def project(self, *args):
        """project(self, SbVec2f point) -> SbVec3f"""
        return _coin.SbPlaneProjector_project(self, *args)

    def tryProject(self, *args):
        """tryProject(self, SbVec2f point, float epsilon, SbVec3f result) -> SbBool"""
        return _coin.SbPlaneProjector_tryProject(self, *args)

    def setPlane(self, *args):
        """setPlane(self, SbPlane plane)"""
        return _coin.SbPlaneProjector_setPlane(self, *args)

    def getPlane(self):
        """getPlane(self) -> SbPlane"""
        return _coin.SbPlaneProjector_getPlane(self)

    def setOrientToEye(self, *args):
        """setOrientToEye(self, SbBool orienttoeye)"""
        return _coin.SbPlaneProjector_setOrientToEye(self, *args)

    def isOrientToEye(self):
        """isOrientToEye(self) -> SbBool"""
        return _coin.SbPlaneProjector_isOrientToEye(self)

    def getVector(self, *args):
        """
        getVector(self, SbVec2f viewpos1, SbVec2f viewpos2) -> SbVec3f
        getVector(self, SbVec2f viewpos) -> SbVec3f
        """
        return _coin.SbPlaneProjector_getVector(self, *args)

    def setStartPosition(self, *args):
        """
        setStartPosition(self, SbVec2f viewpos)
        setStartPosition(self, SbVec3f point)
        """
        return _coin.SbPlaneProjector_setStartPosition(self, *args)

    __swig_destroy__ = _coin.delete_SbPlaneProjector
    __del__ = lambda self : None;
SbPlaneProjector_swigregister = _coin.SbPlaneProjector_swigregister
SbPlaneProjector_swigregister(SbPlaneProjector)

class SbSphere(object):
    """Proxy of C++ SbSphere class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbSphere
        __init__(self, SbVec3f center, float radius) -> SbSphere
        """
        this = _coin.new_SbSphere(*args)
        try: self.this.append(this)
        except: self.this = this
    def setValue(self, *args):
        """setValue(self, SbVec3f center, float radius)"""
        return _coin.SbSphere_setValue(self, *args)

    def setCenter(self, *args):
        """setCenter(self, SbVec3f center)"""
        return _coin.SbSphere_setCenter(self, *args)

    def setRadius(self, *args):
        """setRadius(self, float radius)"""
        return _coin.SbSphere_setRadius(self, *args)

    def getCenter(self):
        """getCenter(self) -> SbVec3f"""
        return _coin.SbSphere_getCenter(self)

    def getRadius(self):
        """getRadius(self) -> float"""
        return _coin.SbSphere_getRadius(self)

    def circumscribe(self, *args):
        """circumscribe(self, SbBox3f box)"""
        return _coin.SbSphere_circumscribe(self, *args)

    def intersect(self, *args):
        """
        intersect(self, SbLine l, SbVec3f intersection) -> SbBool
        intersect(self, SbLine l, SbVec3f enter, SbVec3f exit) -> SbBool
        """
        return _coin.SbSphere_intersect(self, *args)

    def pointInside(self, *args):
        """pointInside(self, SbVec3f p) -> SbBool"""
        return _coin.SbSphere_pointInside(self, *args)

    def output(self, *args):
        """output(self, FILE file)"""
        return _coin.SbSphere_output(self, *args)

    __swig_destroy__ = _coin.delete_SbSphere
    __del__ = lambda self : None;
SbSphere_swigregister = _coin.SbSphere_swigregister
SbSphere_swigregister(SbSphere)

class SbSphereProjector(SbProjector):
    """Proxy of C++ SbSphereProjector class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def projectAndGetRotation(self, *args):
        """projectAndGetRotation(self, SbVec2f point, SbRotation rot) -> SbVec3f"""
        return _coin.SbSphereProjector_projectAndGetRotation(self, *args)

    def getRotation(self, *args):
        """getRotation(self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbSphereProjector_getRotation(self, *args)

    def setSphere(self, *args):
        """setSphere(self, SbSphere sph)"""
        return _coin.SbSphereProjector_setSphere(self, *args)

    def getSphere(self):
        """getSphere(self) -> SbSphere"""
        return _coin.SbSphereProjector_getSphere(self)

    def setOrientToEye(self, *args):
        """setOrientToEye(self, SbBool orienttoeye)"""
        return _coin.SbSphereProjector_setOrientToEye(self, *args)

    def isOrientToEye(self):
        """isOrientToEye(self) -> SbBool"""
        return _coin.SbSphereProjector_isOrientToEye(self)

    def setFront(self, *args):
        """setFront(self, SbBool infront)"""
        return _coin.SbSphereProjector_setFront(self, *args)

    def isFront(self):
        """isFront(self) -> SbBool"""
        return _coin.SbSphereProjector_isFront(self)

    def isPointInFront(self, *args):
        """isPointInFront(self, SbVec3f point) -> SbBool"""
        return _coin.SbSphereProjector_isPointInFront(self, *args)

    def setWorkingSpace(self, *args):
        """setWorkingSpace(self, SbMatrix space)"""
        return _coin.SbSphereProjector_setWorkingSpace(self, *args)

    __swig_destroy__ = _coin.delete_SbSphereProjector
    __del__ = lambda self : None;
SbSphereProjector_swigregister = _coin.SbSphereProjector_swigregister
SbSphereProjector_swigregister(SbSphereProjector)

class SbSphereSheetProjector(SbSphereProjector):
    """Proxy of C++ SbSphereSheetProjector class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, SbBool orienttoeye = 1) -> SbSphereSheetProjector
        __init__(self) -> SbSphereSheetProjector
        __init__(self, SbSphere sph, SbBool orienttoeye = 1) -> SbSphereSheetProjector
        __init__(self, SbSphere sph) -> SbSphereSheetProjector
        """
        this = _coin.new_SbSphereSheetProjector(*args)
        try: self.this.append(this)
        except: self.this = this
    def copy(self):
        """copy(self) -> SbProjector"""
        return _coin.SbSphereSheetProjector_copy(self)

    def project(self, *args):
        """project(self, SbVec2f point) -> SbVec3f"""
        return _coin.SbSphereSheetProjector_project(self, *args)

    def getRotation(self, *args):
        """getRotation(self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbSphereSheetProjector_getRotation(self, *args)

    __swig_destroy__ = _coin.delete_SbSphereSheetProjector
    __del__ = lambda self : None;
SbSphereSheetProjector_swigregister = _coin.SbSphereSheetProjector_swigregister
SbSphereSheetProjector_swigregister(SbSphereSheetProjector)

class SbSphereSectionProjector(SbSphereProjector):
    """Proxy of C++ SbSphereSectionProjector class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, float edgetol = 0.9, SbBool orienttoeye = 1) -> SbSphereSectionProjector
        __init__(self, float edgetol = 0.9) -> SbSphereSectionProjector
        __init__(self) -> SbSphereSectionProjector
        __init__(self, SbSphere sph, float edgetol = 0.9, SbBool orienttoeye = 1) -> SbSphereSectionProjector
        __init__(self, SbSphere sph, float edgetol = 0.9) -> SbSphereSectionProjector
        __init__(self, SbSphere sph) -> SbSphereSectionProjector
        """
        this = _coin.new_SbSphereSectionProjector(*args)
        try: self.this.append(this)
        except: self.this = this
    def copy(self):
        """copy(self) -> SbProjector"""
        return _coin.SbSphereSectionProjector_copy(self)

    def project(self, *args):
        """project(self, SbVec2f point) -> SbVec3f"""
        return _coin.SbSphereSectionProjector_project(self, *args)

    def getRotation(self, *args):
        """getRotation(self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbSphereSectionProjector_getRotation(self, *args)

    def setTolerance(self, *args):
        """setTolerance(self, float edgetol)"""
        return _coin.SbSphereSectionProjector_setTolerance(self, *args)

    def getTolerance(self):
        """getTolerance(self) -> float"""
        return _coin.SbSphereSectionProjector_getTolerance(self)

    def setRadialFactor(self, rad = 0.0):
        """
        setRadialFactor(self, float rad = 0.0)
        setRadialFactor(self)
        """
        return _coin.SbSphereSectionProjector_setRadialFactor(self, rad)

    def getRadialFactor(self):
        """getRadialFactor(self) -> float"""
        return _coin.SbSphereSectionProjector_getRadialFactor(self)

    def isWithinTolerance(self, *args):
        """isWithinTolerance(self, SbVec3f point) -> SbBool"""
        return _coin.SbSphereSectionProjector_isWithinTolerance(self, *args)

    __swig_destroy__ = _coin.delete_SbSphereSectionProjector
    __del__ = lambda self : None;
SbSphereSectionProjector_swigregister = _coin.SbSphereSectionProjector_swigregister
SbSphereSectionProjector_swigregister(SbSphereSectionProjector)

class SbSpherePlaneProjector(SbSphereSectionProjector):
    """Proxy of C++ SbSpherePlaneProjector class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, float edgetol = 0.9, SbBool orienttoeye = 1) -> SbSpherePlaneProjector
        __init__(self, float edgetol = 0.9) -> SbSpherePlaneProjector
        __init__(self) -> SbSpherePlaneProjector
        __init__(self, SbSphere sph, float edgetol = 0.9, SbBool orienttoeye = 1) -> SbSpherePlaneProjector
        __init__(self, SbSphere sph, float edgetol = 0.9) -> SbSpherePlaneProjector
        __init__(self, SbSphere sph) -> SbSpherePlaneProjector
        """
        this = _coin.new_SbSpherePlaneProjector(*args)
        try: self.this.append(this)
        except: self.this = this
    def copy(self):
        """copy(self) -> SbProjector"""
        return _coin.SbSpherePlaneProjector_copy(self)

    def project(self, *args):
        """project(self, SbVec2f point) -> SbVec3f"""
        return _coin.SbSpherePlaneProjector_project(self, *args)

    def getRotation(self, *args):
        """getRotation(self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbSpherePlaneProjector_getRotation(self, *args)

    __swig_destroy__ = _coin.delete_SbSpherePlaneProjector
    __del__ = lambda self : None;
SbSpherePlaneProjector_swigregister = _coin.SbSpherePlaneProjector_swigregister
SbSpherePlaneProjector_swigregister(SbSpherePlaneProjector)

class SbClip(object):
    """Proxy of C++ SbClip class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, callback = None, userdata = None): 
        """
        __init__(self, SbClipCallback callback = None, void userdata = None) -> SbClip
        __init__(self, SbClipCallback callback = None) -> SbClip
        __init__(self) -> SbClip
        """
        this = _coin.new_SbClip(callback, userdata)
        try: self.this.append(this)
        except: self.this = this
    def addVertex(self, *args):
        """
        addVertex(self, SbVec3f v, void vdata = None)
        addVertex(self, SbVec3f v)
        """
        return _coin.SbClip_addVertex(self, *args)

    def reset(self):
        """reset(self)"""
        return _coin.SbClip_reset(self)

    def clip(self, *args):
        """clip(self, SbPlane plane)"""
        return _coin.SbClip_clip(self, *args)

    def getNumVertices(self):
        """getNumVertices(self) -> int"""
        return _coin.SbClip_getNumVertices(self)

    def getVertex(self, *args):
        """
        getVertex(self, int idx, SbVec3f v, void vdata = None)
        getVertex(self, int idx, SbVec3f v)
        """
        return _coin.SbClip_getVertex(self, *args)

    def getVertexData(self, *args):
        """getVertexData(self, int idx) -> void"""
        return _coin.SbClip_getVertexData(self, *args)

    __swig_destroy__ = _coin.delete_SbClip
    __del__ = lambda self : None;
SbClip_swigregister = _coin.SbClip_swigregister
SbClip_swigregister(SbClip)

class SbDPRotation(object):
    """Proxy of C++ SbDPRotation class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbDPRotation
        __init__(self, SbVec3d axis, double radians) -> SbDPRotation
        __init__(self, double q) -> SbDPRotation
        __init__(self, double q0, double q1, double q2, double q3) -> SbDPRotation
        __init__(self, SbDPMatrix m) -> SbDPRotation
        __init__(self, SbVec3d rotateFrom, SbVec3d rotateTo) -> SbDPRotation
        """
        this = _coin.new_SbDPRotation(*args)
        try: self.this.append(this)
        except: self.this = this
    def getValue(self):
        """getValue(self) -> double"""
        return _coin.SbDPRotation_getValue(self)

    def getAxisAngle(self):
        """getAxisAngle(self)"""
        return _coin.SbDPRotation_getAxisAngle(self)

    def getMatrix(self):
        """getMatrix(self)"""
        return _coin.SbDPRotation_getMatrix(self)

    def invert(self):
        """invert(self) -> SbDPRotation"""
        return _coin.SbDPRotation_invert(self)

    def inverse(self):
        """inverse(self) -> SbDPRotation"""
        return _coin.SbDPRotation_inverse(self)

    def setValue(self, *args):
        """
        setValue(self, double q0, double q1, double q2, double q3) -> SbDPRotation
        setValue(self, double q) -> SbDPRotation
        setValue(self, SbDPMatrix m) -> SbDPRotation
        setValue(self, SbVec3d axis, double radians) -> SbDPRotation
        setValue(self, SbVec3d rotateFrom, SbVec3d rotateTo) -> SbDPRotation
        """
        return _coin.SbDPRotation_setValue(self, *args)

    def __imul__(self, *args):
        """
        __imul__(self, SbDPRotation q) -> SbDPRotation
        __imul__(self, double s) -> SbDPRotation
        """
        return _coin.SbDPRotation___imul__(self, *args)

    def equals(self, *args):
        """equals(self, SbDPRotation r, double tolerance) -> SbBool"""
        return _coin.SbDPRotation_equals(self, *args)

    def multVec(self, *args):
        """multVec(self, SbVec3d src, SbVec3d dst)"""
        return _coin.SbDPRotation_multVec(self, *args)

    def scaleAngle(self, *args):
        """scaleAngle(self, double scaleFactor)"""
        return _coin.SbDPRotation_scaleAngle(self, *args)

    def slerp(*args):
        """slerp(SbDPRotation rot0, SbDPRotation rot1, double t) -> SbDPRotation"""
        return _coin.SbDPRotation_slerp(*args)

    slerp = staticmethod(slerp)
    def identity():
        """identity() -> SbDPRotation"""
        return _coin.SbDPRotation_identity()

    identity = staticmethod(identity)
    def output(self, *args):
        """output(self, FILE fp)"""
        return _coin.SbDPRotation_output(self, *args)

    def __mul__(self, *args):
        """
        __mul__(self, SbDPRotation u) -> SbDPRotation
        __mul__(self, double d) -> SbDPRotation
        __mul__(self, SbVec3d v) -> SbVec3d
        """
        return _coin.SbDPRotation___mul__(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SbDPRotation u) -> int"""
        return _coin.SbDPRotation___eq__(self, *args)

    def __nq__(self, *args):
        """__nq__(self, SbDPRotation u) -> int"""
        return _coin.SbDPRotation___nq__(self, *args)

    __swig_destroy__ = _coin.delete_SbDPRotation
    __del__ = lambda self : None;
SbDPRotation_swigregister = _coin.SbDPRotation_swigregister
SbDPRotation_swigregister(SbDPRotation)

def SbDPRotation_slerp(*args):
  """SbDPRotation_slerp(SbDPRotation rot0, SbDPRotation rot1, double t) -> SbDPRotation"""
  return _coin.SbDPRotation_slerp(*args)

def SbDPRotation_identity():
  """SbDPRotation_identity() -> SbDPRotation"""
  return _coin.SbDPRotation_identity()

class SbDPMatrix(object):
    """Proxy of C++ SbDPMatrix class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbDPMatrix
        __init__(self, double a11, double a12, double a13, double a14, double a21, 
            double a22, double a23, double a24, 
            double a31, double a32, double a33, double a34, 
            double a41, double a42, double a43, double a44) -> SbDPMatrix
        __init__(self, SbDPMat matrix) -> SbDPMatrix
        __init__(self, SbDPMat matrix) -> SbDPMatrix
        __init__(self) -> SbDPMatrix
        """
        this = _coin.new_SbDPMatrix(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SbDPMatrix
    __del__ = lambda self : None;
    def setValue(self, *args):
        """setValue(self, SbDPMat m)"""
        return _coin.SbDPMatrix_setValue(self, *args)

    def makeIdentity(self):
        """makeIdentity(self)"""
        return _coin.SbDPMatrix_makeIdentity(self)

    def setRotate(self, *args):
        """setRotate(self, SbDPRotation q)"""
        return _coin.SbDPMatrix_setRotate(self, *args)

    def inverse(self):
        """inverse(self) -> SbDPMatrix"""
        return _coin.SbDPMatrix_inverse(self)

    def det3(self, *args):
        """
        det3(self, int r1, int r2, int r3, int c1, int c2, int c3) -> double
        det3(self) -> double
        """
        return _coin.SbDPMatrix_det3(self, *args)

    def det4(self):
        """det4(self) -> double"""
        return _coin.SbDPMatrix_det4(self)

    def equals(self, *args):
        """equals(self, SbDPMatrix m, double tolerance) -> SbBool"""
        return _coin.SbDPMatrix_equals(self, *args)

    def __imul__(self, *args):
        """__imul__(self, SbDPMatrix m) -> SbDPMatrix"""
        return _coin.SbDPMatrix___imul__(self, *args)

    def getValue(self, *args):
        """
        getValue(self) -> SbDPMat
        getValue(self, SbDPMat m)
        """
        return _coin.SbDPMatrix_getValue(self, *args)

    def identity():
        """identity() -> SbDPMatrix"""
        return _coin.SbDPMatrix_identity()

    identity = staticmethod(identity)
    def setScale(self, *args):
        """
        setScale(self, double s)
        setScale(self, SbVec3d s)
        """
        return _coin.SbDPMatrix_setScale(self, *args)

    def setTranslate(self, *args):
        """setTranslate(self, SbVec3d t)"""
        return _coin.SbDPMatrix_setTranslate(self, *args)

    def setTransform(self, *args):
        """
        setTransform(self, SbVec3d t, SbDPRotation r, SbVec3d s)
        setTransform(self, SbVec3d t, SbDPRotation r, SbVec3d s, SbDPRotation so)
        setTransform(self, SbVec3d translation, SbDPRotation rotation, SbVec3d scaleFactor, 
            SbDPRotation scaleOrientation, 
            SbVec3d center)
        """
        return _coin.SbDPMatrix_setTransform(self, *args)

    def getTransform(self, *args):
        """
        getTransform(self, SbVec3d t, SbDPRotation r, SbVec3d s, SbDPRotation so)
        getTransform(self, SbVec3d translation, SbDPRotation rotation, SbVec3d scaleFactor, 
            SbDPRotation scaleOrientation, 
            SbVec3d center)
        """
        return _coin.SbDPMatrix_getTransform(self, *args)

    def factor(self, *args):
        """factor(self, SbDPMatrix r, SbVec3d s, SbDPMatrix u, SbVec3d t, SbDPMatrix proj) -> SbBool"""
        return _coin.SbDPMatrix_factor(self, *args)

    def LUDecomposition(self, *args):
        """LUDecomposition(self, int index, double d) -> SbBool"""
        return _coin.SbDPMatrix_LUDecomposition(self, *args)

    def LUBackSubstitution(self, *args):
        """LUBackSubstitution(self, int index, double b)"""
        return _coin.SbDPMatrix_LUBackSubstitution(self, *args)

    def transpose(self):
        """transpose(self) -> SbDPMatrix"""
        return _coin.SbDPMatrix_transpose(self)

    def multRight(self, *args):
        """multRight(self, SbDPMatrix m) -> SbDPMatrix"""
        return _coin.SbDPMatrix_multRight(self, *args)

    def multLeft(self, *args):
        """multLeft(self, SbDPMatrix m) -> SbDPMatrix"""
        return _coin.SbDPMatrix_multLeft(self, *args)

    def multMatrixVec(self, *args):
        """multMatrixVec(self, SbVec3d src, SbVec3d dst)"""
        return _coin.SbDPMatrix_multMatrixVec(self, *args)

    def multDirMatrix(self, *args):
        """multDirMatrix(self, SbVec3d src, SbVec3d dst)"""
        return _coin.SbDPMatrix_multDirMatrix(self, *args)

    def multLineMatrix(self, *args):
        """multLineMatrix(self, SbDPLine src, SbDPLine dst)"""
        return _coin.SbDPMatrix_multLineMatrix(self, *args)

    def multVecMatrix(self, *args):
        """
        multVecMatrix(self, SbVec3d src, SbVec3d dst)
        multVecMatrix(self, SbVec4d src, SbVec4d dst)
        """
        return _coin.SbDPMatrix_multVecMatrix(self, *args)

    def output(self, *args):
        """output(self, FILE fp)"""
        return _coin.SbDPMatrix_output(self, *args)

    def __mul__(self, *args):
        """
        __mul__(self, SbDPMatrix u) -> SbDPMatrix
        __mul__(self, SbVec3d u) -> SbVec3d
        """
        return _coin.SbDPMatrix___mul__(self, *args)

    def __rmul__(self, *args):
        """__rmul__(self, SbVec3d u) -> SbVec3d"""
        return _coin.SbDPMatrix___rmul__(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SbDPMatrix u) -> int"""
        return _coin.SbDPMatrix___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SbDPMatrix u) -> int"""
        return _coin.SbDPMatrix___ne__(self, *args)

SbDPMatrix_swigregister = _coin.SbDPMatrix_swigregister
SbDPMatrix_swigregister(SbDPMatrix)

def SbDPMatrix_identity():
  """SbDPMatrix_identity() -> SbDPMatrix"""
  return _coin.SbDPMatrix_identity()

class SbDPLine(object):
    """Proxy of C++ SbDPLine class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbDPLine
        __init__(self, SbVec3d p0, SbVec3d p1) -> SbDPLine
        """
        this = _coin.new_SbDPLine(*args)
        try: self.this.append(this)
        except: self.this = this
    def setValue(self, *args):
        """setValue(self, SbVec3d p0, SbVec3d p1)"""
        return _coin.SbDPLine_setValue(self, *args)

    def getClosestPoints(self, *args):
        """getClosestPoints(self, SbDPLine line2, SbVec3d ptOnThis, SbVec3d ptOnLine2) -> SbBool"""
        return _coin.SbDPLine_getClosestPoints(self, *args)

    def getClosestPoint(self, *args):
        """getClosestPoint(self, SbVec3d point) -> SbVec3d"""
        return _coin.SbDPLine_getClosestPoint(self, *args)

    def getPosition(self):
        """getPosition(self) -> SbVec3d"""
        return _coin.SbDPLine_getPosition(self)

    def getDirection(self):
        """getDirection(self) -> SbVec3d"""
        return _coin.SbDPLine_getDirection(self)

    def output(self, *args):
        """output(self, FILE file)"""
        return _coin.SbDPLine_output(self, *args)

    __swig_destroy__ = _coin.delete_SbDPLine
    __del__ = lambda self : None;
SbDPLine_swigregister = _coin.SbDPLine_swigregister
SbDPLine_swigregister(SbDPLine)

class SbDPPlane(object):
    """Proxy of C++ SbDPPlane class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbDPPlane
        __init__(self, SbVec3d normal, double D) -> SbDPPlane
        __init__(self, SbVec3d p0, SbVec3d p1, SbVec3d p2) -> SbDPPlane
        __init__(self, SbVec3d normal, SbVec3d point) -> SbDPPlane
        """
        this = _coin.new_SbDPPlane(*args)
        try: self.this.append(this)
        except: self.this = this
    def offset(self, *args):
        """offset(self, double d)"""
        return _coin.SbDPPlane_offset(self, *args)

    def transform(self):
        """transform(self)"""
        return _coin.SbDPPlane_transform(self)

    def isInHalfSpace(self, *args):
        """isInHalfSpace(self, SbVec3d point) -> SbBool"""
        return _coin.SbDPPlane_isInHalfSpace(self, *args)

    def getDistance(self, *args):
        """getDistance(self, SbVec3d point) -> double"""
        return _coin.SbDPPlane_getDistance(self, *args)

    def getNormal(self):
        """getNormal(self) -> SbVec3d"""
        return _coin.SbDPPlane_getNormal(self)

    def getDistanceFromOrigin(self):
        """getDistanceFromOrigin(self) -> double"""
        return _coin.SbDPPlane_getDistanceFromOrigin(self)

    def output(self, *args):
        """output(self, FILE file)"""
        return _coin.SbDPPlane_output(self, *args)

    def intersect(self, *args):
        """
        intersect(self, SbDPLine l, SbVec3d intersection) -> SbBool
        intersect(self, SbDPPlane pl, SbDPLine line) -> SbBool
        """
        return _coin.SbDPPlane_intersect(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SbDPPlane u) -> int"""
        return _coin.SbDPPlane___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SbDPPlane u) -> int"""
        return _coin.SbDPPlane___ne__(self, *args)

    __swig_destroy__ = _coin.delete_SbDPPlane
    __del__ = lambda self : None;
SbDPPlane_swigregister = _coin.SbDPPlane_swigregister
SbDPPlane_swigregister(SbDPPlane)

class SbHeapFuncs(object):
    """Proxy of C++ SbHeapFuncs class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    eval_func = _swig_property(_coin.SbHeapFuncs_eval_func_get, _coin.SbHeapFuncs_eval_func_set)
    get_index_func = _swig_property(_coin.SbHeapFuncs_get_index_func_get, _coin.SbHeapFuncs_get_index_func_set)
    set_index_func = _swig_property(_coin.SbHeapFuncs_set_index_func_get, _coin.SbHeapFuncs_set_index_func_set)
    def __init__(self): 
        """__init__(self) -> SbHeapFuncs"""
        this = _coin.new_SbHeapFuncs()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SbHeapFuncs
    __del__ = lambda self : None;
SbHeapFuncs_swigregister = _coin.SbHeapFuncs_swigregister
SbHeapFuncs_swigregister(SbHeapFuncs)

class SbHeap(object):
    """Proxy of C++ SbHeap class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, SbHeapFuncs SbHeapFuncs, int initsize = 1024) -> SbHeap
        __init__(self, SbHeapFuncs SbHeapFuncs) -> SbHeap
        """
        this = _coin.new_SbHeap(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SbHeap
    __del__ = lambda self : None;
    def emptyHeap(self):
        """emptyHeap(self)"""
        return _coin.SbHeap_emptyHeap(self)

    def size(self):
        """size(self) -> int"""
        return _coin.SbHeap_size(self)

    def add(self, *args):
        """add(self, void obj) -> int"""
        return _coin.SbHeap_add(self, *args)

    def remove(self, *args):
        """
        remove(self, int pos)
        remove(self, void obj)
        """
        return _coin.SbHeap_remove(self, *args)

    def extractMin(self):
        """extractMin(self) -> void"""
        return _coin.SbHeap_extractMin(self)

    def getMin(self):
        """getMin(self) -> void"""
        return _coin.SbHeap_getMin(self)

    def newWeight(self, *args):
        """
        newWeight(self, void obj, int hpos = -1)
        newWeight(self, void obj)
        """
        return _coin.SbHeap_newWeight(self, *args)

    def buildHeap(self, progresscb = None, data = None):
        """
        buildHeap(self, SbBool progresscb = None, void data = None) -> SbBool
        buildHeap(self, SbBool progresscb = None) -> SbBool
        buildHeap(self) -> SbBool
        """
        return _coin.SbHeap_buildHeap(self, progresscb, data)

    def traverseHeap(self, *args):
        """traverseHeap(self, SbBool func, void userdata) -> SbBool"""
        return _coin.SbHeap_traverseHeap(self, *args)

SbHeap_swigregister = _coin.SbHeap_swigregister
SbHeap_swigregister(SbHeap)

class SbImage(object):
    """Proxy of C++ SbImage class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SbImage
        __init__(self, unsigned char bytes) -> SbImage
        __init__(self, unsigned char bytes) -> SbImage
        """
        this = _coin.new_SbImage(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SbImage
    __del__ = lambda self : None;
    def setValue(self, *args):
        """
        setValue(self, SbVec2s size)
        setValue(self, SbVec3s size)
        """
        return _coin.SbImage_setValue(self, *args)

    def setValuePtr(self, *args):
        """
        setValuePtr(self, SbVec2s size)
        setValuePtr(self, SbVec3s size)
        """
        return _coin.SbImage_setValuePtr(self, *args)

    def getSize(self):
        """getSize(self) -> SbVec3s"""
        return _coin.SbImage_getSize(self)

    def readFile(self, *args):
        """
        readFile(self, SbString filename, SbString searchdirectories = None, 
            int numdirectories = 0) -> SbBool
        readFile(self, SbString filename, SbString searchdirectories = None) -> SbBool
        readFile(self, SbString filename) -> SbBool
        """
        return _coin.SbImage_readFile(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SbImage image) -> int"""
        return _coin.SbImage___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SbImage image) -> int"""
        return _coin.SbImage___ne__(self, *args)

    def addReadImageCB(*args):
        """addReadImageCB(SbImageReadImageCB cb, void closure)"""
        return _coin.SbImage_addReadImageCB(*args)

    addReadImageCB = staticmethod(addReadImageCB)
    def removeReadImageCB(*args):
        """removeReadImageCB(SbImageReadImageCB cb, void closure)"""
        return _coin.SbImage_removeReadImageCB(*args)

    removeReadImageCB = staticmethod(removeReadImageCB)
    def searchForFile(*args):
        """searchForFile(SbString basename, SbString dirlist, int numdirs) -> SbString"""
        return _coin.SbImage_searchForFile(*args)

    searchForFile = staticmethod(searchForFile)
    def hasData(self):
        """hasData(self) -> SbBool"""
        return _coin.SbImage_hasData(self)

    def readLock(self):
        """readLock(self)"""
        return _coin.SbImage_readLock(self)

    def readUnlock(self):
        """readUnlock(self)"""
        return _coin.SbImage_readUnlock(self)

    def scheduleReadFile(self, *args):
        """
        scheduleReadFile(self, SbImageScheduleReadCB cb, void closure, SbString filename, 
            SbString searchdirectories = None, int numdirectories = 0) -> SbBool
        scheduleReadFile(self, SbImageScheduleReadCB cb, void closure, SbString filename, 
            SbString searchdirectories = None) -> SbBool
        scheduleReadFile(self, SbImageScheduleReadCB cb, void closure, SbString filename) -> SbBool
        """
        return _coin.SbImage_scheduleReadFile(self, *args)

    def getValue(self, *args):
        """
        getValue(self, SbVec2s size, int bytesperpixel) -> unsigned char
        getValue(self, SbVec3s size, int bytesperpixel) -> unsigned char
        getValue(self) -> PyObject
        """
        return _coin.SbImage_getValue(self, *args)

SbImage_swigregister = _coin.SbImage_swigregister
SbImage_swigregister(SbImage)

def SbImage_addReadImageCB(*args):
  """SbImage_addReadImageCB(SbImageReadImageCB cb, void closure)"""
  return _coin.SbImage_addReadImageCB(*args)

def SbImage_removeReadImageCB(*args):
  """SbImage_removeReadImageCB(SbImageReadImageCB cb, void closure)"""
  return _coin.SbImage_removeReadImageCB(*args)

def SbImage_searchForFile(*args):
  """SbImage_searchForFile(SbString basename, SbString dirlist, int numdirs) -> SbString"""
  return _coin.SbImage_searchForFile(*args)

class SbOctTreeFuncs(object):
    """Proxy of C++ SbOctTreeFuncs class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ptinsidefunc = _swig_property(_coin.SbOctTreeFuncs_ptinsidefunc_get, _coin.SbOctTreeFuncs_ptinsidefunc_set)
    insideboxfunc = _swig_property(_coin.SbOctTreeFuncs_insideboxfunc_get, _coin.SbOctTreeFuncs_insideboxfunc_set)
    insidespherefunc = _swig_property(_coin.SbOctTreeFuncs_insidespherefunc_get, _coin.SbOctTreeFuncs_insidespherefunc_set)
    insideplanesfunc = _swig_property(_coin.SbOctTreeFuncs_insideplanesfunc_get, _coin.SbOctTreeFuncs_insideplanesfunc_set)
    def __init__(self): 
        """__init__(self) -> SbOctTreeFuncs"""
        this = _coin.new_SbOctTreeFuncs()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SbOctTreeFuncs
    __del__ = lambda self : None;
SbOctTreeFuncs_swigregister = _coin.SbOctTreeFuncs_swigregister
SbOctTreeFuncs_swigregister(SbOctTreeFuncs)

class SbOctTree(object):
    """Proxy of C++ SbOctTree class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, SbBox3f bbox, SbOctTreeFuncs itemfuncs, int maxitemspernode = 64) -> SbOctTree
        __init__(self, SbBox3f bbox, SbOctTreeFuncs itemfuncs) -> SbOctTree
        """
        this = _coin.new_SbOctTree(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SbOctTree
    __del__ = lambda self : None;
    def addItem(self, *args):
        """addItem(self, void item)"""
        return _coin.SbOctTree_addItem(self, *args)

    def removeItem(self, *args):
        """removeItem(self, void item)"""
        return _coin.SbOctTree_removeItem(self, *args)

    def findItems(self, *args):
        """
        findItems(self, SbVec3f pos, SbList<(p.void)> destarray, SbBool removeduplicates = 1)
        findItems(self, SbVec3f pos, SbList<(p.void)> destarray)
        findItems(self, SbBox3f box, SbList<(p.void)> destarray, SbBool removeduplicates = 1)
        findItems(self, SbBox3f box, SbList<(p.void)> destarray)
        findItems(self, SbSphere sphere, SbList<(p.void)> destarray, SbBool removeduplicates = 1)
        findItems(self, SbSphere sphere, SbList<(p.void)> destarray)
        findItems(self, SbPlane planes, int numplanes, SbList<(p.void)> destarray, 
            SbBool removeduplicates = 1)
        findItems(self, SbPlane planes, int numplanes, SbList<(p.void)> destarray)
        """
        return _coin.SbOctTree_findItems(self, *args)

    def getBoundingBox(self):
        """getBoundingBox(self) -> SbBox3f"""
        return _coin.SbOctTree_getBoundingBox(self)

    def clear(self):
        """clear(self)"""
        return _coin.SbOctTree_clear(self)

    def debugTree(self, *args):
        """debugTree(self, FILE fp)"""
        return _coin.SbOctTree_debugTree(self, *args)

SbOctTree_swigregister = _coin.SbOctTree_swigregister
SbOctTree_swigregister(SbOctTree)

class SbTesselator(object):
    """Proxy of C++ SbTesselator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, func = None, data = None): 
        """
        __init__(self, SbTesselatorCB func = None, void data = None) -> SbTesselator
        __init__(self, SbTesselatorCB func = None) -> SbTesselator
        __init__(self) -> SbTesselator
        """
        this = _coin.new_SbTesselator(func, data)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SbTesselator
    __del__ = lambda self : None;
    def beginPolygon(self, *args):
        """
        beginPolygon(self, SbBool keepVertices = 0, SbVec3f normal = SbVec3f(0.0f, 0.0f, 0.0f))
        beginPolygon(self, SbBool keepVertices = 0)
        beginPolygon(self)
        """
        return _coin.SbTesselator_beginPolygon(self, *args)

    def addVertex(self, *args):
        """addVertex(self, SbVec3f v, void data)"""
        return _coin.SbTesselator_addVertex(self, *args)

    def endPolygon(self):
        """endPolygon(self)"""
        return _coin.SbTesselator_endPolygon(self)

    def setCallback(self, *args):
        """setCallback(self, SbTesselatorCB func, void data)"""
        return _coin.SbTesselator_setCallback(self, *args)

SbTesselator_swigregister = _coin.SbTesselator_swigregister
SbTesselator_swigregister(SbTesselator)

class SoTimerQueueSensor(SoSensor):
    """Proxy of C++ SoTimerQueueSensor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
       newobj = None
       if len(args) == 2:
          args = (args[0], (args[0], args[1], "SoTimerQueueSensor *"))
          newobj = apply(_coin.new_SoTimerQueueSensor_scb_v, args)
       else:
          self.this = apply(_coin.new_SoTimerQueueSensor, args)
       if newobj:
          self.this = newobj.this
          self.thisown = 1


    __swig_destroy__ = _coin.delete_SoTimerQueueSensor
    __del__ = lambda self : None;
    def getTriggerTime(self):
        """getTriggerTime(self) -> SbTime"""
        return _coin.SoTimerQueueSensor_getTriggerTime(self)

    def schedule(self):
        """schedule(self)"""
        return _coin.SoTimerQueueSensor_schedule(self)

    def unschedule(self):
        """unschedule(self)"""
        return _coin.SoTimerQueueSensor_unschedule(self)

    def isScheduled(self):
        """isScheduled(self) -> SbBool"""
        return _coin.SoTimerQueueSensor_isScheduled(self)

    def trigger(self):
        """trigger(self)"""
        return _coin.SoTimerQueueSensor_trigger(self)

SoTimerQueueSensor_swigregister = _coin.SoTimerQueueSensor_swigregister
SoTimerQueueSensor_swigregister(SoTimerQueueSensor)
def __init__(self, *args):
   newobj = None
   if len(args) == 2:
      args = (args[0], (args[0], args[1], "SoTimerQueueSensor *"))
      newobj = apply(_coin.new_SoTimerQueueSensor_scb_v, args)
   else:
      self.this = apply(_coin.new_SoTimerQueueSensor, args)
   if newobj:
      self.this = newobj.this
      self.thisown = 1



class SoAlarmSensor(SoTimerQueueSensor):
    """Proxy of C++ SoAlarmSensor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
       newobj = None
       if len(args) == 2:
          args = (args[0], (args[0], args[1], "SoAlarmSensor *"))
          newobj = apply(_coin.new_SoAlarmSensor_scb_v, args)
       else:
          newobj = apply(_coin.new_SoAlarmSensor, args)
       if newobj:
          self.this = newobj.this
          self.thisown = 1


    __swig_destroy__ = _coin.delete_SoAlarmSensor
    __del__ = lambda self : None;
    def setTime(self, *args):
        """setTime(self, SbTime abstime)"""
        return _coin.SoAlarmSensor_setTime(self, *args)

    def setTimeFromNow(self, *args):
        """setTimeFromNow(self, SbTime reltime)"""
        return _coin.SoAlarmSensor_setTimeFromNow(self, *args)

    def getTime(self):
        """getTime(self) -> SbTime"""
        return _coin.SoAlarmSensor_getTime(self)

    def schedule(self):
        """schedule(self)"""
        return _coin.SoAlarmSensor_schedule(self)

SoAlarmSensor_swigregister = _coin.SoAlarmSensor_swigregister
SoAlarmSensor_swigregister(SoAlarmSensor)
def __init__(self, *args):
   newobj = None
   if len(args) == 2:
      args = (args[0], (args[0], args[1], "SoAlarmSensor *"))
      newobj = apply(_coin.new_SoAlarmSensor_scb_v, args)
   else:
      newobj = apply(_coin.new_SoAlarmSensor, args)
   if newobj:
      self.this = newobj.this
      self.thisown = 1



class SoIdleSensor(SoDelayQueueSensor):
    """Proxy of C++ SoIdleSensor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
       newobj = None
       if len(args) == 2:
          args = (args[0], (args[0], args[1], "SoIdleSensor *"))
          newobj = apply(_coin.new_SoIdleSensor_scb_v, args)
       else:
          newobj = apply(_coin.new_SoIdleSensor, args)
       if newobj:
          self.this = newobj.this
          self.thisown = 1


    __swig_destroy__ = _coin.delete_SoIdleSensor
    __del__ = lambda self : None;
SoIdleSensor_swigregister = _coin.SoIdleSensor_swigregister
SoIdleSensor_swigregister(SoIdleSensor)
def __init__(self, *args):
   newobj = None
   if len(args) == 2:
      args = (args[0], (args[0], args[1], "SoIdleSensor *"))
      newobj = apply(_coin.new_SoIdleSensor_scb_v, args)
   else:
      newobj = apply(_coin.new_SoIdleSensor, args)
   if newobj:
      self.this = newobj.this
      self.thisown = 1



class SoNodeSensor(SoDataSensor):
    """Proxy of C++ SoNodeSensor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
       newobj = None
       if len(args) == 2:
          args = (args[0], (args[0], args[1], "SoNodeSensor *"))
          newobj = apply(_coin.new_SoNodeSensor_scb_v, args)
       else:
          newobj = apply(_coin.new_SoNodeSensor, args)
       if newobj:
          self.this = newobj.this
          self.thisown = 1


    __swig_destroy__ = _coin.delete_SoNodeSensor
    __del__ = lambda self : None;
    def attach(self, *args):
        """attach(self, SoNode node)"""
        return _coin.SoNodeSensor_attach(self, *args)

    def detach(self):
        """detach(self)"""
        return _coin.SoNodeSensor_detach(self)

    def getAttachedNode(self):
        """getAttachedNode(self) -> SoNode"""
        return _coin.SoNodeSensor_getAttachedNode(self)

SoNodeSensor_swigregister = _coin.SoNodeSensor_swigregister
SoNodeSensor_swigregister(SoNodeSensor)
def __init__(self, *args):
   newobj = None
   if len(args) == 2:
      args = (args[0], (args[0], args[1], "SoNodeSensor *"))
      newobj = apply(_coin.new_SoNodeSensor_scb_v, args)
   else:
      newobj = apply(_coin.new_SoNodeSensor, args)
   if newobj:
      self.this = newobj.this
      self.thisown = 1



class SoOneShotSensor(SoDelayQueueSensor):
    """Proxy of C++ SoOneShotSensor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
       newobj = None
       if len(args) == 2:
          args = (args[0], (args[0], args[1], "SoOneShotSensor *"))
          newobj = apply(_coin.new_SoOneShotSensor_scb_v, args)
       else:
          newobj = apply(_coin.new_SoOneShotSensor, args)
       if newobj:
          self.this = newobj.this
          self.thisown = 1


    __swig_destroy__ = _coin.delete_SoOneShotSensor
    __del__ = lambda self : None;
SoOneShotSensor_swigregister = _coin.SoOneShotSensor_swigregister
SoOneShotSensor_swigregister(SoOneShotSensor)
def __init__(self, *args):
   newobj = None
   if len(args) == 2:
      args = (args[0], (args[0], args[1], "SoOneShotSensor *"))
      newobj = apply(_coin.new_SoOneShotSensor_scb_v, args)
   else:
      newobj = apply(_coin.new_SoOneShotSensor, args)
   if newobj:
      self.this = newobj.this
      self.thisown = 1



class SoPathSensor(SoDataSensor):
    """Proxy of C++ SoPathSensor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
       newobj = None
       if len(args) == 2:
          args = (args[0], (args[0], args[1], "SoPathSensor *"))
          newobj = apply(_coin.new_SoPathSensor_scb_v, args)
       else:
          newobj = apply(_coin.new_SoPathSensor, args)
       if newobj:
          self.this = newobj.this
          self.thisown = 1


    __swig_destroy__ = _coin.delete_SoPathSensor
    __del__ = lambda self : None;
    PATH = _coin.SoPathSensor_PATH
    NODES = _coin.SoPathSensor_NODES
    PATH_AND_NODES = _coin.SoPathSensor_PATH_AND_NODES
    def setTriggerFilter(self, *args):
        """setTriggerFilter(self, TriggerFilter type)"""
        return _coin.SoPathSensor_setTriggerFilter(self, *args)

    def getTriggerFilter(self):
        """getTriggerFilter(self) -> TriggerFilter"""
        return _coin.SoPathSensor_getTriggerFilter(self)

    def attach(self, *args):
        """attach(self, SoPath path)"""
        return _coin.SoPathSensor_attach(self, *args)

    def detach(self):
        """detach(self)"""
        return _coin.SoPathSensor_detach(self)

    def getAttachedPath(self):
        """getAttachedPath(self) -> SoPath"""
        return _coin.SoPathSensor_getAttachedPath(self)

SoPathSensor_swigregister = _coin.SoPathSensor_swigregister
SoPathSensor_swigregister(SoPathSensor)
def __init__(self, *args):
   newobj = None
   if len(args) == 2:
      args = (args[0], (args[0], args[1], "SoPathSensor *"))
      newobj = apply(_coin.new_SoPathSensor_scb_v, args)
   else:
      newobj = apply(_coin.new_SoPathSensor, args)
   if newobj:
      self.this = newobj.this
      self.thisown = 1



class SoTimerSensor(SoTimerQueueSensor):
    """Proxy of C++ SoTimerSensor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args):
       newobj = None
       if len(args) == 2:
          args = (args[0], (args[0], args[1], "SoTimerSensor *"))
          newobj = apply(_coin.new_SoTimerSensor_scb_v, args)
       else:
          newobj = apply(_coin.new_SoTimerSensor, args)
       if newobj:
          self.this = newobj.this
          self.thisown = 1


    __swig_destroy__ = _coin.delete_SoTimerSensor
    __del__ = lambda self : None;
    def setBaseTime(self, *args):
        """setBaseTime(self, SbTime base)"""
        return _coin.SoTimerSensor_setBaseTime(self, *args)

    def getBaseTime(self):
        """getBaseTime(self) -> SbTime"""
        return _coin.SoTimerSensor_getBaseTime(self)

    def setInterval(self, *args):
        """setInterval(self, SbTime interval)"""
        return _coin.SoTimerSensor_setInterval(self, *args)

    def getInterval(self):
        """getInterval(self) -> SbTime"""
        return _coin.SoTimerSensor_getInterval(self)

    def schedule(self):
        """schedule(self)"""
        return _coin.SoTimerSensor_schedule(self)

    def unschedule(self):
        """unschedule(self)"""
        return _coin.SoTimerSensor_unschedule(self)

    def reschedule(self, *args):
        """reschedule(self, SbTime schedtime)"""
        return _coin.SoTimerSensor_reschedule(self, *args)

SoTimerSensor_swigregister = _coin.SoTimerSensor_swigregister
SoTimerSensor_swigregister(SoTimerSensor)
def __init__(self, *args):
   newobj = None
   if len(args) == 2:
      args = (args[0], (args[0], args[1], "SoTimerSensor *"))
      newobj = apply(_coin.new_SoTimerSensor_scb_v, args)
   else:
      newobj = apply(_coin.new_SoTimerSensor, args)
   if newobj:
      self.this = newobj.this
      self.thisown = 1



class SoInteraction(object):
    """Proxy of C++ SoInteraction class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def init():
        """init()"""
        return _coin.SoInteraction_init()

    init = staticmethod(init)
    def __init__(self): 
        """__init__(self) -> SoInteraction"""
        this = _coin.new_SoInteraction()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoInteraction
    __del__ = lambda self : None;
SoInteraction_swigregister = _coin.SoInteraction_swigregister
SoInteraction_swigregister(SoInteraction)

def SoInteraction_init():
  """SoInteraction_init()"""
  return _coin.SoInteraction_init()

class SoOffscreenRenderer(object):
    """Proxy of C++ SoOffscreenRenderer class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    LUMINANCE = _coin.SoOffscreenRenderer_LUMINANCE
    LUMINANCE_TRANSPARENCY = _coin.SoOffscreenRenderer_LUMINANCE_TRANSPARENCY
    RGB = _coin.SoOffscreenRenderer_RGB
    RGB_TRANSPARENCY = _coin.SoOffscreenRenderer_RGB_TRANSPARENCY
    def __init__(self, *args): 
        """
        __init__(self, SbViewportRegion viewportregion) -> SoOffscreenRenderer
        __init__(self, SoGLRenderAction action) -> SoOffscreenRenderer
        """
        this = _coin.new_SoOffscreenRenderer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoOffscreenRenderer
    __del__ = lambda self : None;
    def getScreenPixelsPerInch():
        """getScreenPixelsPerInch() -> float"""
        return _coin.SoOffscreenRenderer_getScreenPixelsPerInch()

    getScreenPixelsPerInch = staticmethod(getScreenPixelsPerInch)
    def getMaximumResolution():
        """getMaximumResolution() -> SbVec2s"""
        return _coin.SoOffscreenRenderer_getMaximumResolution()

    getMaximumResolution = staticmethod(getMaximumResolution)
    def setComponents(self, *args):
        """setComponents(self, Components components)"""
        return _coin.SoOffscreenRenderer_setComponents(self, *args)

    def getComponents(self):
        """getComponents(self) -> Components"""
        return _coin.SoOffscreenRenderer_getComponents(self)

    def setViewportRegion(self, *args):
        """setViewportRegion(self, SbViewportRegion region)"""
        return _coin.SoOffscreenRenderer_setViewportRegion(self, *args)

    def getViewportRegion(self):
        """getViewportRegion(self) -> SbViewportRegion"""
        return _coin.SoOffscreenRenderer_getViewportRegion(self)

    def setBackgroundColor(self, *args):
        """setBackgroundColor(self, SbColor color)"""
        return _coin.SoOffscreenRenderer_setBackgroundColor(self, *args)

    def getBackgroundColor(self):
        """getBackgroundColor(self) -> SbColor"""
        return _coin.SoOffscreenRenderer_getBackgroundColor(self)

    def setGLRenderAction(self, *args):
        """setGLRenderAction(self, SoGLRenderAction action)"""
        return _coin.SoOffscreenRenderer_setGLRenderAction(self, *args)

    def getGLRenderAction(self):
        """getGLRenderAction(self) -> SoGLRenderAction"""
        return _coin.SoOffscreenRenderer_getGLRenderAction(self)

    def render(self, *args):
        """
        render(self, SoNode scene) -> SbBool
        render(self, SoPath scene) -> SbBool
        """
        return _coin.SoOffscreenRenderer_render(self, *args)

    def getDC(self):
        """getDC(self) -> void"""
        return _coin.SoOffscreenRenderer_getDC(self)

    def writeToRGB(self, *args):
        """
        writeToRGB(self, FILE fp) -> SbBool
        writeToRGB(self, char filename) -> SbBool
        """
        return _coin.SoOffscreenRenderer_writeToRGB(self, *args)

    def writeToPostScript(self, *args):
        """
        writeToPostScript(self, FILE fp) -> SbBool
        writeToPostScript(self, FILE fp, SbVec2f printsize) -> SbBool
        writeToPostScript(self, char filename) -> SbBool
        writeToPostScript(self, char filename, SbVec2f printsize) -> SbBool
        """
        return _coin.SoOffscreenRenderer_writeToPostScript(self, *args)

    def isWriteSupported(self, *args):
        """isWriteSupported(self, SbName filetypeextension) -> SbBool"""
        return _coin.SoOffscreenRenderer_isWriteSupported(self, *args)

    def getNumWriteFiletypes(self):
        """getNumWriteFiletypes(self) -> int"""
        return _coin.SoOffscreenRenderer_getNumWriteFiletypes(self)

    def writeToFile(self, *args):
        """writeToFile(self, SbString filename, SbName filetypeextension) -> SbBool"""
        return _coin.SoOffscreenRenderer_writeToFile(self, *args)

    def setPbufferEnable(self, *args):
        """setPbufferEnable(self, SbBool enable)"""
        return _coin.SoOffscreenRenderer_setPbufferEnable(self, *args)

    def getPbufferEnable(self):
        """getPbufferEnable(self) -> SbBool"""
        return _coin.SoOffscreenRenderer_getPbufferEnable(self)

    def getWriteFiletypeInfo(self, *args):
        """
        getWriteFiletypeInfo(self, int idx, SbPList extlist, SbString fullname, SbString description)
        getWriteFiletypeInfo(self, int idx, SbList<(SbName)> extlist, SbString fullname, 
            SbString description)
        """
        return _coin.SoOffscreenRenderer_getWriteFiletypeInfo(self, *args)

    def getBuffer(self, *args):
        """
        getBuffer(self) -> unsigned char
        getBuffer(self) -> PyObject
        """
        return _coin.SoOffscreenRenderer_getBuffer(self, *args)

SoOffscreenRenderer_swigregister = _coin.SoOffscreenRenderer_swigregister
SoOffscreenRenderer_swigregister(SoOffscreenRenderer)

def SoOffscreenRenderer_getScreenPixelsPerInch():
  """SoOffscreenRenderer_getScreenPixelsPerInch() -> float"""
  return _coin.SoOffscreenRenderer_getScreenPixelsPerInch()

def SoOffscreenRenderer_getMaximumResolution():
  """SoOffscreenRenderer_getMaximumResolution() -> SbVec2s"""
  return _coin.SoOffscreenRenderer_getMaximumResolution()

class SoPickedPoint(object):
    """Proxy of C++ SoPickedPoint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, SoPickedPoint pp) -> SoPickedPoint
        __init__(self, SoPath path, SoState state, SbVec3f objSpacePoint) -> SoPickedPoint
        """
        this = _coin.new_SoPickedPoint(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoPickedPoint
    __del__ = lambda self : None;
    def copy(self):
        """copy(self) -> SoPickedPoint"""
        return _coin.SoPickedPoint_copy(self)

    def getPoint(self):
        """getPoint(self) -> SbVec3f"""
        return _coin.SoPickedPoint_getPoint(self)

    def getNormal(self):
        """getNormal(self) -> SbVec3f"""
        return _coin.SoPickedPoint_getNormal(self)

    def getTextureCoords(self):
        """getTextureCoords(self) -> SbVec4f"""
        return _coin.SoPickedPoint_getTextureCoords(self)

    def getMaterialIndex(self):
        """getMaterialIndex(self) -> int"""
        return _coin.SoPickedPoint_getMaterialIndex(self)

    def getPath(self):
        """getPath(self) -> SoPath"""
        return _coin.SoPickedPoint_getPath(self)

    def isOnGeometry(self):
        """isOnGeometry(self) -> SbBool"""
        return _coin.SoPickedPoint_isOnGeometry(self)

    def getDetail(self, node = None):
        """
        getDetail(self, SoNode node = None) -> SoDetail
        getDetail(self) -> SoDetail
        """
        return _coin.SoPickedPoint_getDetail(self, node)

    def getObjectToWorld(self, node = None):
        """
        getObjectToWorld(self, SoNode node = None) -> SbMatrix
        getObjectToWorld(self) -> SbMatrix
        """
        return _coin.SoPickedPoint_getObjectToWorld(self, node)

    def getWorldToObject(self, node = None):
        """
        getWorldToObject(self, SoNode node = None) -> SbMatrix
        getWorldToObject(self) -> SbMatrix
        """
        return _coin.SoPickedPoint_getWorldToObject(self, node)

    def getObjectToImage(self, node = None):
        """
        getObjectToImage(self, SoNode node = None) -> SbMatrix
        getObjectToImage(self) -> SbMatrix
        """
        return _coin.SoPickedPoint_getObjectToImage(self, node)

    def getImageToObject(self, node = None):
        """
        getImageToObject(self, SoNode node = None) -> SbMatrix
        getImageToObject(self) -> SbMatrix
        """
        return _coin.SoPickedPoint_getImageToObject(self, node)

    def getObjectPoint(self, node = None):
        """
        getObjectPoint(self, SoNode node = None) -> SbVec3f
        getObjectPoint(self) -> SbVec3f
        """
        return _coin.SoPickedPoint_getObjectPoint(self, node)

    def getObjectNormal(self, node = None):
        """
        getObjectNormal(self, SoNode node = None) -> SbVec3f
        getObjectNormal(self) -> SbVec3f
        """
        return _coin.SoPickedPoint_getObjectNormal(self, node)

    def getObjectTextureCoords(self, node = None):
        """
        getObjectTextureCoords(self, SoNode node = None) -> SbVec4f
        getObjectTextureCoords(self) -> SbVec4f
        """
        return _coin.SoPickedPoint_getObjectTextureCoords(self, node)

    def setObjectNormal(self, *args):
        """setObjectNormal(self, SbVec3f normal)"""
        return _coin.SoPickedPoint_setObjectNormal(self, *args)

    def setObjectTextureCoords(self, *args):
        """setObjectTextureCoords(self, SbVec4f texCoords)"""
        return _coin.SoPickedPoint_setObjectTextureCoords(self, *args)

    def setMaterialIndex(self, *args):
        """setMaterialIndex(self, int index)"""
        return _coin.SoPickedPoint_setMaterialIndex(self, *args)

    def setDetail(self, *args):
        """setDetail(self, SoDetail detail, SoNode node)"""
        return _coin.SoPickedPoint_setDetail(self, *args)

SoPickedPoint_swigregister = _coin.SoPickedPoint_swigregister
SoPickedPoint_swigregister(SoPickedPoint)

class SoPrimitiveVertex(object):
    """Proxy of C++ SoPrimitiveVertex class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SoPrimitiveVertex
        __init__(self, SoPrimitiveVertex pv) -> SoPrimitiveVertex
        """
        this = _coin.new_SoPrimitiveVertex(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoPrimitiveVertex
    __del__ = lambda self : None;
    def getPoint(self):
        """getPoint(self) -> SbVec3f"""
        return _coin.SoPrimitiveVertex_getPoint(self)

    def getNormal(self):
        """getNormal(self) -> SbVec3f"""
        return _coin.SoPrimitiveVertex_getNormal(self)

    def getTextureCoords(self):
        """getTextureCoords(self) -> SbVec4f"""
        return _coin.SoPrimitiveVertex_getTextureCoords(self)

    def getMaterialIndex(self):
        """getMaterialIndex(self) -> int"""
        return _coin.SoPrimitiveVertex_getMaterialIndex(self)

    def getPackedColor(self):
        """getPackedColor(self) -> uint32_t"""
        return _coin.SoPrimitiveVertex_getPackedColor(self)

    def getDetail(self):
        """getDetail(self) -> SoDetail"""
        return _coin.SoPrimitiveVertex_getDetail(self)

    def setPoint(self, *args):
        """
        setPoint(self, SbVec3f pt)
        setPoint(self, float x, float y, float z)
        """
        return _coin.SoPrimitiveVertex_setPoint(self, *args)

    def setNormal(self, *args):
        """
        setNormal(self, SbVec3f n)
        setNormal(self, float nx, float ny, float nz)
        """
        return _coin.SoPrimitiveVertex_setNormal(self, *args)

    def setTextureCoords(self, *args):
        """
        setTextureCoords(self, SbVec2f tex)
        setTextureCoords(self, float tx, float ty)
        setTextureCoords(self, SbVec3f tex)
        setTextureCoords(self, float tx, float ty, float tz)
        setTextureCoords(self, SbVec4f tex)
        setTextureCoords(self, float tx, float ty, float tz, float tw)
        """
        return _coin.SoPrimitiveVertex_setTextureCoords(self, *args)

    def setMaterialIndex(self, *args):
        """setMaterialIndex(self, int index)"""
        return _coin.SoPrimitiveVertex_setMaterialIndex(self, *args)

    def setPackedColor(self, *args):
        """setPackedColor(self, uint32_t rgba)"""
        return _coin.SoPrimitiveVertex_setPackedColor(self, *args)

    def setDetail(self, *args):
        """setDetail(self, SoDetail d)"""
        return _coin.SoPrimitiveVertex_setDetail(self, *args)

SoPrimitiveVertex_swigregister = _coin.SoPrimitiveVertex_swigregister
SoPrimitiveVertex_swigregister(SoPrimitiveVertex)

class SoSceneManager(object):
    """Proxy of C++ SoSceneManager class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoSceneManager"""
        this = _coin.new_SoSceneManager()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoSceneManager
    __del__ = lambda self : None;
    def render(self, *args):
        """
        render(self, SbBool clearwindow = 1, SbBool clearzbuffer = 1)
        render(self, SbBool clearwindow = 1)
        render(self)
        render(self, SoGLRenderAction action, SbBool initmatrices = 1, SbBool clearwindow = 1, 
            SbBool clearzbuffer = 1)
        render(self, SoGLRenderAction action, SbBool initmatrices = 1, SbBool clearwindow = 1)
        render(self, SoGLRenderAction action, SbBool initmatrices = 1)
        render(self, SoGLRenderAction action)
        """
        return _coin.SoSceneManager_render(self, *args)

    def setCamera(self, *args):
        """setCamera(self, SoCamera camera)"""
        return _coin.SoSceneManager_setCamera(self, *args)

    def getCamera(self):
        """getCamera(self) -> SoCamera"""
        return _coin.SoSceneManager_getCamera(self)

    def processEvent(self, *args):
        """processEvent(self, SoEvent event) -> SbBool"""
        return _coin.SoSceneManager_processEvent(self, *args)

    def reinitialize(self):
        """reinitialize(self)"""
        return _coin.SoSceneManager_reinitialize(self)

    def scheduleRedraw(self):
        """scheduleRedraw(self)"""
        return _coin.SoSceneManager_scheduleRedraw(self)

    def setSceneGraph(self, *args):
        """setSceneGraph(self, SoNode sceneroot)"""
        return _coin.SoSceneManager_setSceneGraph(self, *args)

    def getSceneGraph(self):
        """getSceneGraph(self) -> SoNode"""
        return _coin.SoSceneManager_getSceneGraph(self)

    def setWindowSize(self, *args):
        """setWindowSize(self, SbVec2s newsize)"""
        return _coin.SoSceneManager_setWindowSize(self, *args)

    def getWindowSize(self):
        """getWindowSize(self) -> SbVec2s"""
        return _coin.SoSceneManager_getWindowSize(self)

    def setSize(self, *args):
        """setSize(self, SbVec2s newsize)"""
        return _coin.SoSceneManager_setSize(self, *args)

    def getSize(self):
        """getSize(self) -> SbVec2s"""
        return _coin.SoSceneManager_getSize(self)

    def setOrigin(self, *args):
        """setOrigin(self, SbVec2s newOrigin)"""
        return _coin.SoSceneManager_setOrigin(self, *args)

    def getOrigin(self):
        """getOrigin(self) -> SbVec2s"""
        return _coin.SoSceneManager_getOrigin(self)

    def setViewportRegion(self, *args):
        """setViewportRegion(self, SbViewportRegion newRegion)"""
        return _coin.SoSceneManager_setViewportRegion(self, *args)

    def getViewportRegion(self):
        """getViewportRegion(self) -> SbViewportRegion"""
        return _coin.SoSceneManager_getViewportRegion(self)

    def setBackgroundColor(self, *args):
        """setBackgroundColor(self, SbColor color)"""
        return _coin.SoSceneManager_setBackgroundColor(self, *args)

    def getBackgroundColor(self):
        """getBackgroundColor(self) -> SbColor"""
        return _coin.SoSceneManager_getBackgroundColor(self)

    def setBackgroundIndex(self, *args):
        """setBackgroundIndex(self, int index)"""
        return _coin.SoSceneManager_setBackgroundIndex(self, *args)

    def getBackgroundIndex(self):
        """getBackgroundIndex(self) -> int"""
        return _coin.SoSceneManager_getBackgroundIndex(self)

    def setRGBMode(self, *args):
        """setRGBMode(self, SbBool onOrOff)"""
        return _coin.SoSceneManager_setRGBMode(self, *args)

    def isRGBMode(self):
        """isRGBMode(self) -> SbBool"""
        return _coin.SoSceneManager_isRGBMode(self)

    def activate(self):
        """activate(self)"""
        return _coin.SoSceneManager_activate(self)

    def deactivate(self):
        """deactivate(self)"""
        return _coin.SoSceneManager_deactivate(self)

    def isAutoRedraw(self):
        """isAutoRedraw(self) -> SbBool"""
        return _coin.SoSceneManager_isAutoRedraw(self)

    def setRedrawPriority(self, *args):
        """setRedrawPriority(self, uint32_t priority)"""
        return _coin.SoSceneManager_setRedrawPriority(self, *args)

    def getRedrawPriority(self):
        """getRedrawPriority(self) -> uint32_t"""
        return _coin.SoSceneManager_getRedrawPriority(self)

    def setAntialiasing(self, *args):
        """setAntialiasing(self, SbBool smoothing, int numPasses)"""
        return _coin.SoSceneManager_setAntialiasing(self, *args)

    def getAntialiasing(self, *args):
        """getAntialiasing(self, SbBool smoothing, int numPasses)"""
        return _coin.SoSceneManager_getAntialiasing(self, *args)

    def setGLRenderAction(self, *args):
        """setGLRenderAction(self, SoGLRenderAction action)"""
        return _coin.SoSceneManager_setGLRenderAction(self, *args)

    def getGLRenderAction(self):
        """getGLRenderAction(self) -> SoGLRenderAction"""
        return _coin.SoSceneManager_getGLRenderAction(self)

    def setAudioRenderAction(self, *args):
        """setAudioRenderAction(self, SoAudioRenderAction action)"""
        return _coin.SoSceneManager_setAudioRenderAction(self, *args)

    def getAudioRenderAction(self):
        """getAudioRenderAction(self) -> SoAudioRenderAction"""
        return _coin.SoSceneManager_getAudioRenderAction(self)

    def setHandleEventAction(self, *args):
        """setHandleEventAction(self, SoHandleEventAction hea)"""
        return _coin.SoSceneManager_setHandleEventAction(self, *args)

    def getHandleEventAction(self):
        """getHandleEventAction(self) -> SoHandleEventAction"""
        return _coin.SoSceneManager_getHandleEventAction(self)

    def getDefaultRedrawPriority():
        """getDefaultRedrawPriority() -> uint32_t"""
        return _coin.SoSceneManager_getDefaultRedrawPriority()

    getDefaultRedrawPriority = staticmethod(getDefaultRedrawPriority)
    def enableRealTimeUpdate(*args):
        """enableRealTimeUpdate(SbBool flag)"""
        return _coin.SoSceneManager_enableRealTimeUpdate(*args)

    enableRealTimeUpdate = staticmethod(enableRealTimeUpdate)
    def isRealTimeUpdateEnabled():
        """isRealTimeUpdateEnabled() -> SbBool"""
        return _coin.SoSceneManager_isRealTimeUpdateEnabled()

    isRealTimeUpdateEnabled = staticmethod(isRealTimeUpdateEnabled)
    def setRenderCallback(self, *args):
        """
        setRenderCallback(self, SoSceneManagerRenderCB f, void userData = None)
        setRenderCallback(self, SoSceneManagerRenderCB f)
        setRenderCallback(self, PyObject pyfunc, PyObject userData = None)
        setRenderCallback(self, PyObject pyfunc)
        """
        return _coin.SoSceneManager_setRenderCallback(self, *args)

SoSceneManager_swigregister = _coin.SoSceneManager_swigregister
SoSceneManager_swigregister(SoSceneManager)

def SoSceneManager_getDefaultRedrawPriority():
  """SoSceneManager_getDefaultRedrawPriority() -> uint32_t"""
  return _coin.SoSceneManager_getDefaultRedrawPriority()

def SoSceneManager_enableRealTimeUpdate(*args):
  """SoSceneManager_enableRealTimeUpdate(SbBool flag)"""
  return _coin.SoSceneManager_enableRealTimeUpdate(*args)

def SoSceneManager_isRealTimeUpdateEnabled():
  """SoSceneManager_isRealTimeUpdateEnabled() -> SbBool"""
  return _coin.SoSceneManager_isRealTimeUpdateEnabled()

GL_GLEXT_PROTOTYPES = _coin.GL_GLEXT_PROTOTYPES
GL_CLAMP_TO_EDGE = _coin.GL_CLAMP_TO_EDGE
GL_CLAMP_TO_BORDER = _coin.GL_CLAMP_TO_BORDER
GL_REPLACE = _coin.GL_REPLACE
GL_MAX_3D_TEXTURE_SIZE = _coin.GL_MAX_3D_TEXTURE_SIZE
GL_PACK_IMAGE_HEIGHT = _coin.GL_PACK_IMAGE_HEIGHT
GL_PACK_SKIP_IMAGES = _coin.GL_PACK_SKIP_IMAGES
GL_PROXY_TEXTURE_2D = _coin.GL_PROXY_TEXTURE_2D
GL_PROXY_TEXTURE_3D = _coin.GL_PROXY_TEXTURE_3D
GL_TEXTURE_3D = _coin.GL_TEXTURE_3D
GL_TEXTURE_DEPTH = _coin.GL_TEXTURE_DEPTH
GL_TEXTURE_WRAP_R = _coin.GL_TEXTURE_WRAP_R
GL_UNPACK_IMAGE_HEIGHT = _coin.GL_UNPACK_IMAGE_HEIGHT
GL_UNPACK_SKIP_IMAGES = _coin.GL_UNPACK_SKIP_IMAGES
GL_COLOR_TABLE_WIDTH = _coin.GL_COLOR_TABLE_WIDTH
GL_TEXTURE0 = _coin.GL_TEXTURE0
GL_TEXTURE1 = _coin.GL_TEXTURE1
GL_TEXTURE2 = _coin.GL_TEXTURE2
GL_TEXTURE3 = _coin.GL_TEXTURE3
GL_TEXTURE4 = _coin.GL_TEXTURE4
GL_TEXTURE5 = _coin.GL_TEXTURE5
GL_TEXTURE6 = _coin.GL_TEXTURE6
GL_TEXTURE7 = _coin.GL_TEXTURE7
GL_TEXTURE8 = _coin.GL_TEXTURE8
GL_TEXTURE9 = _coin.GL_TEXTURE9
GL_TEXTURE10 = _coin.GL_TEXTURE10
GL_TEXTURE11 = _coin.GL_TEXTURE11
GL_TEXTURE12 = _coin.GL_TEXTURE12
GL_TEXTURE13 = _coin.GL_TEXTURE13
GL_TEXTURE14 = _coin.GL_TEXTURE14
GL_TEXTURE15 = _coin.GL_TEXTURE15
GL_MAX_TEXTURE_UNITS = _coin.GL_MAX_TEXTURE_UNITS
GL_ACTIVE_TEXTURE = _coin.GL_ACTIVE_TEXTURE
GL_CLIENT_ACTIVE_TEXTURE = _coin.GL_CLIENT_ACTIVE_TEXTURE
GL_POLYGON_OFFSET_EXT = _coin.GL_POLYGON_OFFSET_EXT
GL_COLOR_TABLE = _coin.GL_COLOR_TABLE
GL_COLOR_INDEX1_EXT = _coin.GL_COLOR_INDEX1_EXT
GL_COLOR_INDEX2_EXT = _coin.GL_COLOR_INDEX2_EXT
GL_COLOR_INDEX4_EXT = _coin.GL_COLOR_INDEX4_EXT
GL_COLOR_INDEX8_EXT = _coin.GL_COLOR_INDEX8_EXT
GL_COLOR_INDEX12_EXT = _coin.GL_COLOR_INDEX12_EXT
GL_COLOR_INDEX16_EXT = _coin.GL_COLOR_INDEX16_EXT
GL_COLOR_TABLE_FORMAT_EXT = _coin.GL_COLOR_TABLE_FORMAT_EXT
GL_COLOR_TABLE_RED_SIZE_EXT = _coin.GL_COLOR_TABLE_RED_SIZE_EXT
GL_COLOR_TABLE_GREEN_SIZE_EXT = _coin.GL_COLOR_TABLE_GREEN_SIZE_EXT
GL_COLOR_TABLE_BLUE_SIZE_EXT = _coin.GL_COLOR_TABLE_BLUE_SIZE_EXT
GL_COLOR_TABLE_ALPHA_SIZE_EXT = _coin.GL_COLOR_TABLE_ALPHA_SIZE_EXT
GL_COLOR_TABLE_LUMINANCE_SIZE_EXT = _coin.GL_COLOR_TABLE_LUMINANCE_SIZE_EXT
GL_COLOR_TABLE_INTENSITY_SIZE_EXT = _coin.GL_COLOR_TABLE_INTENSITY_SIZE_EXT
GL_TEXTURE_INDEX_SIZE_EXT = _coin.GL_TEXTURE_INDEX_SIZE_EXT
GL_COMPRESSED_ALPHA_ARB = _coin.GL_COMPRESSED_ALPHA_ARB
GL_COMPRESSED_LUMINANCE_ARB = _coin.GL_COMPRESSED_LUMINANCE_ARB
GL_COMPRESSED_LUMINANCE_ALPHA_ARB = _coin.GL_COMPRESSED_LUMINANCE_ALPHA_ARB
GL_COMPRESSED_INTENSITY_ARB = _coin.GL_COMPRESSED_INTENSITY_ARB
GL_COMPRESSED_RGB_ARB = _coin.GL_COMPRESSED_RGB_ARB
GL_COMPRESSED_RGBA_ARB = _coin.GL_COMPRESSED_RGBA_ARB
GL_TEXTURE_COMPRESSION_HINT_ARB = _coin.GL_TEXTURE_COMPRESSION_HINT_ARB
GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = _coin.GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB
GL_TEXTURE_COMPRESSED_ARB = _coin.GL_TEXTURE_COMPRESSED_ARB
GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB = _coin.GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB
GL_COMPRESSED_TEXTURE_FORMATS_ARB = _coin.GL_COMPRESSED_TEXTURE_FORMATS_ARB
GL_DEPTH_COMPONENT16 = _coin.GL_DEPTH_COMPONENT16
GL_DEPTH_COMPONENT24 = _coin.GL_DEPTH_COMPONENT24
GL_DEPTH_COMPONENT32 = _coin.GL_DEPTH_COMPONENT32
GL_TEXTURE_DEPTH_SIZE = _coin.GL_TEXTURE_DEPTH_SIZE
GL_DEPTH_TEXTURE_MODE = _coin.GL_DEPTH_TEXTURE_MODE
GL_R3_G3_B2 = _coin.GL_R3_G3_B2
GL_RGB4 = _coin.GL_RGB4
GL_RGB5 = _coin.GL_RGB5
GL_RGB8 = _coin.GL_RGB8
GL_RGB10 = _coin.GL_RGB10
GL_RGB12 = _coin.GL_RGB12
GL_RGB16 = _coin.GL_RGB16
GL_RGBA2 = _coin.GL_RGBA2
GL_RGBA4 = _coin.GL_RGBA4
GL_RGB5_A1 = _coin.GL_RGB5_A1
GL_RGBA8 = _coin.GL_RGBA8
GL_RGB10_A2 = _coin.GL_RGB10_A2
GL_RGBA12 = _coin.GL_RGBA12
GL_RGBA16 = _coin.GL_RGBA16
GL_RGBA32F_ARB = _coin.GL_RGBA32F_ARB
GL_RGB32F_ARB = _coin.GL_RGB32F_ARB
GL_ALPHA32F_ARB = _coin.GL_ALPHA32F_ARB
GL_INTENSITY32F_ARB = _coin.GL_INTENSITY32F_ARB
GL_LUMINANCE32F_ARB = _coin.GL_LUMINANCE32F_ARB
GL_LUMINANCE_ALPHA32F_ARB = _coin.GL_LUMINANCE_ALPHA32F_ARB
GL_RGBA16F_ARB = _coin.GL_RGBA16F_ARB
GL_RGB16F_ARB = _coin.GL_RGB16F_ARB
GL_ALPHA16F_ARB = _coin.GL_ALPHA16F_ARB
GL_INTENSITY16F_ARB = _coin.GL_INTENSITY16F_ARB
GL_LUMINANCE16F_ARB = _coin.GL_LUMINANCE16F_ARB
GL_LUMINANCE_ALPHA16F_ARB = _coin.GL_LUMINANCE_ALPHA16F_ARB
GL_RGBA16_EXT = _coin.GL_RGBA16_EXT
GL_TEXTURE_COMPARE_MODE = _coin.GL_TEXTURE_COMPARE_MODE
GL_TEXTURE_COMPARE_FUNC = _coin.GL_TEXTURE_COMPARE_FUNC
GL_COMPARE_R_TO_TEXTURE = _coin.GL_COMPARE_R_TO_TEXTURE
GL_MIN = _coin.GL_MIN
GL_MAX = _coin.GL_MAX
GL_FUNC_ADD = _coin.GL_FUNC_ADD
GL_FUNC_SUBTRACT = _coin.GL_FUNC_SUBTRACT
GL_FUNC_REVERSE_SUBTRACT = _coin.GL_FUNC_REVERSE_SUBTRACT
GL_VERTEX_ARRAY = _coin.GL_VERTEX_ARRAY
GL_NORMAL_ARRAY = _coin.GL_NORMAL_ARRAY
GL_COLOR_ARRAY = _coin.GL_COLOR_ARRAY
GL_INDEX_ARRAY = _coin.GL_INDEX_ARRAY
GL_TEXTURE_COORD_ARRAY = _coin.GL_TEXTURE_COORD_ARRAY
GL_V3F = _coin.GL_V3F
GL_C4UB_V3F = _coin.GL_C4UB_V3F
GL_C3F_V3F = _coin.GL_C3F_V3F
GL_N3F_V3F = _coin.GL_N3F_V3F
GL_C4F_N3F_V3F = _coin.GL_C4F_N3F_V3F
GL_T2F_V3F = _coin.GL_T2F_V3F
GL_T2F_C4UB_V3F = _coin.GL_T2F_C4UB_V3F
GL_T2F_C3F_V3F = _coin.GL_T2F_C3F_V3F
GL_T2F_N3F_V3F = _coin.GL_T2F_N3F_V3F
GL_T2F_C4F_N3F_V3F = _coin.GL_T2F_C4F_N3F_V3F
GL_VERTEX_ARRAY_RANGE_NV = _coin.GL_VERTEX_ARRAY_RANGE_NV
GL_VERTEX_ARRAY_RANGE_LENGTH_NV = _coin.GL_VERTEX_ARRAY_RANGE_LENGTH_NV
GL_VERTEX_ARRAY_RANGE_VALID_NV = _coin.GL_VERTEX_ARRAY_RANGE_VALID_NV
GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = _coin.GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV
GL_VERTEX_ARRAY_RANGE_POINTER_NV = _coin.GL_VERTEX_ARRAY_RANGE_POINTER_NV
GL_ARRAY_BUFFER = _coin.GL_ARRAY_BUFFER
GL_ELEMENT_ARRAY_BUFFER = _coin.GL_ELEMENT_ARRAY_BUFFER
GL_READ_ONLY = _coin.GL_READ_ONLY
GL_WRITE_ONLY = _coin.GL_WRITE_ONLY
GL_READ_WRITE = _coin.GL_READ_WRITE
GL_BUFFER_ACCESS = _coin.GL_BUFFER_ACCESS
GL_BUFFER_MAPPED = _coin.GL_BUFFER_MAPPED
GL_BUFFER_MAP_POINTER = _coin.GL_BUFFER_MAP_POINTER
GL_STREAM_DRAW = _coin.GL_STREAM_DRAW
GL_STREAM_READ = _coin.GL_STREAM_READ
GL_STREAM_COPY = _coin.GL_STREAM_COPY
GL_STATIC_DRAW = _coin.GL_STATIC_DRAW
GL_STATIC_READ = _coin.GL_STATIC_READ
GL_STATIC_COPY = _coin.GL_STATIC_COPY
GL_DYNAMIC_DRAW = _coin.GL_DYNAMIC_DRAW
GL_DYNAMIC_READ = _coin.GL_DYNAMIC_READ
GL_DYNAMIC_COPY = _coin.GL_DYNAMIC_COPY
GL_REGISTER_COMBINERS_NV = _coin.GL_REGISTER_COMBINERS_NV
GL_COMBINER0_NV = _coin.GL_COMBINER0_NV
GL_COMBINER1_NV = _coin.GL_COMBINER1_NV
GL_COMBINER2_NV = _coin.GL_COMBINER2_NV
GL_COMBINER3_NV = _coin.GL_COMBINER3_NV
GL_COMBINER4_NV = _coin.GL_COMBINER4_NV
GL_COMBINER5_NV = _coin.GL_COMBINER5_NV
GL_COMBINER6_NV = _coin.GL_COMBINER6_NV
GL_COMBINER7_NV = _coin.GL_COMBINER7_NV
GL_VARIABLE_A_NV = _coin.GL_VARIABLE_A_NV
GL_VARIABLE_B_NV = _coin.GL_VARIABLE_B_NV
GL_VARIABLE_C_NV = _coin.GL_VARIABLE_C_NV
GL_VARIABLE_D_NV = _coin.GL_VARIABLE_D_NV
GL_VARIABLE_E_NV = _coin.GL_VARIABLE_E_NV
GL_VARIABLE_F_NV = _coin.GL_VARIABLE_F_NV
GL_VARIABLE_G_NV = _coin.GL_VARIABLE_G_NV
GL_CONSTANT_COLOR0_NV = _coin.GL_CONSTANT_COLOR0_NV
GL_CONSTANT_COLOR1_NV = _coin.GL_CONSTANT_COLOR1_NV
GL_PRIMARY_COLOR_NV = _coin.GL_PRIMARY_COLOR_NV
GL_SECONDARY_COLOR_NV = _coin.GL_SECONDARY_COLOR_NV
GL_SPARE0_NV = _coin.GL_SPARE0_NV
GL_SPARE1_NV = _coin.GL_SPARE1_NV
GL_UNSIGNED_IDENTITY_NV = _coin.GL_UNSIGNED_IDENTITY_NV
GL_UNSIGNED_INVERT_NV = _coin.GL_UNSIGNED_INVERT_NV
GL_EXPAND_NORMAL_NV = _coin.GL_EXPAND_NORMAL_NV
GL_EXPAND_NEGATE_NV = _coin.GL_EXPAND_NEGATE_NV
GL_HALF_BIAS_NORMAL_NV = _coin.GL_HALF_BIAS_NORMAL_NV
GL_HALF_BIAS_NEGATE_NV = _coin.GL_HALF_BIAS_NEGATE_NV
GL_SIGNED_IDENTITY_NV = _coin.GL_SIGNED_IDENTITY_NV
GL_SIGNED_NEGATE_NV = _coin.GL_SIGNED_NEGATE_NV
GL_E_TIMES_F_NV = _coin.GL_E_TIMES_F_NV
GL_SPARE0_PLUS_SECONDARY_COLOR_NV = _coin.GL_SPARE0_PLUS_SECONDARY_COLOR_NV
GL_SCALE_BY_TWO_NV = _coin.GL_SCALE_BY_TWO_NV
GL_SCALE_BY_FOUR_NV = _coin.GL_SCALE_BY_FOUR_NV
GL_SCALE_BY_ONE_HALF_NV = _coin.GL_SCALE_BY_ONE_HALF_NV
GL_BIAS_BY_NEGATIVE_ONE_HALF_NV = _coin.GL_BIAS_BY_NEGATIVE_ONE_HALF_NV
GL_DISCARD_NV = _coin.GL_DISCARD_NV
GL_COMBINER_INPUT_NV = _coin.GL_COMBINER_INPUT_NV
GL_COMBINER_MAPPING_NV = _coin.GL_COMBINER_MAPPING_NV
GL_COMBINER_COMPONENT_USAGE_NV = _coin.GL_COMBINER_COMPONENT_USAGE_NV
GL_COMBINER_AB_DOT_PRODUCT_NV = _coin.GL_COMBINER_AB_DOT_PRODUCT_NV
GL_COMBINER_CD_DOT_PRODUCT_NV = _coin.GL_COMBINER_CD_DOT_PRODUCT_NV
GL_COMBINER_MUX_SUM_NV = _coin.GL_COMBINER_MUX_SUM_NV
GL_COMBINER_SCALE_NV = _coin.GL_COMBINER_SCALE_NV
GL_COMBINER_BIAS_NV = _coin.GL_COMBINER_BIAS_NV
GL_COMBINER_AB_OUTPUT_NV = _coin.GL_COMBINER_AB_OUTPUT_NV
GL_COMBINER_CD_OUTPUT_NV = _coin.GL_COMBINER_CD_OUTPUT_NV
GL_COMBINER_SUM_OUTPUT_NV = _coin.GL_COMBINER_SUM_OUTPUT_NV
GL_MAX_GENERAL_COMBINERS_NV = _coin.GL_MAX_GENERAL_COMBINERS_NV
GL_NUM_GENERAL_COMBINERS_NV = _coin.GL_NUM_GENERAL_COMBINERS_NV
GL_COLOR_SUM_CLAMP_NV = _coin.GL_COLOR_SUM_CLAMP_NV
GL_TEXTURE_RECTANGLE_NV = _coin.GL_TEXTURE_RECTANGLE_NV
GL_TEXTURE_BINDING_RECTANGLE_NV = _coin.GL_TEXTURE_BINDING_RECTANGLE_NV
GL_PROXY_TEXTURE_RECTANGLE_NV = _coin.GL_PROXY_TEXTURE_RECTANGLE_NV
GL_MAX_RECTANGLE_TEXTURE_SIZE_NV = _coin.GL_MAX_RECTANGLE_TEXTURE_SIZE_NV
GL_TEXTURE_RECTANGLE_EXT = _coin.GL_TEXTURE_RECTANGLE_EXT
GL_TEXTURE_BINDING_RECTANGLE_EXT = _coin.GL_TEXTURE_BINDING_RECTANGLE_EXT
GL_PROXY_TEXTURE_RECTANGLE_EXT = _coin.GL_PROXY_TEXTURE_RECTANGLE_EXT
GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT = _coin.GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT
GL_OFFSET_TEXTURE_RECTANGLE_NV = _coin.GL_OFFSET_TEXTURE_RECTANGLE_NV
GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV = _coin.GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV
GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV = _coin.GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV
GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV = _coin.GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV
GL_UNSIGNED_INT_S8_S8_8_8_NV = _coin.GL_UNSIGNED_INT_S8_S8_8_8_NV
GL_UNSIGNED_INT_8_8_S8_S8_REV_NV = _coin.GL_UNSIGNED_INT_8_8_S8_S8_REV_NV
GL_DSDT_MAG_INTENSITY_NV = _coin.GL_DSDT_MAG_INTENSITY_NV
GL_SHADER_CONSISTENT_NV = _coin.GL_SHADER_CONSISTENT_NV
GL_TEXTURE_SHADER_NV = _coin.GL_TEXTURE_SHADER_NV
GL_SHADER_OPERATION_NV = _coin.GL_SHADER_OPERATION_NV
GL_CULL_MODES_NV = _coin.GL_CULL_MODES_NV
GL_OFFSET_TEXTURE_MATRIX_NV = _coin.GL_OFFSET_TEXTURE_MATRIX_NV
GL_OFFSET_TEXTURE_SCALE_NV = _coin.GL_OFFSET_TEXTURE_SCALE_NV
GL_OFFSET_TEXTURE_BIAS_NV = _coin.GL_OFFSET_TEXTURE_BIAS_NV
GL_OFFSET_TEXTURE_2D_MATRIX_NV = _coin.GL_OFFSET_TEXTURE_2D_MATRIX_NV
GL_OFFSET_TEXTURE_2D_SCALE_NV = _coin.GL_OFFSET_TEXTURE_2D_SCALE_NV
GL_OFFSET_TEXTURE_2D_BIAS_NV = _coin.GL_OFFSET_TEXTURE_2D_BIAS_NV
GL_PREVIOUS_TEXTURE_INPUT_NV = _coin.GL_PREVIOUS_TEXTURE_INPUT_NV
GL_CONST_EYE_NV = _coin.GL_CONST_EYE_NV
GL_PASS_THROUGH_NV = _coin.GL_PASS_THROUGH_NV
GL_CULL_FRAGMENT_NV = _coin.GL_CULL_FRAGMENT_NV
GL_OFFSET_TEXTURE_2D_NV = _coin.GL_OFFSET_TEXTURE_2D_NV
GL_DEPENDENT_AR_TEXTURE_2D_NV = _coin.GL_DEPENDENT_AR_TEXTURE_2D_NV
GL_DEPENDENT_GB_TEXTURE_2D_NV = _coin.GL_DEPENDENT_GB_TEXTURE_2D_NV
GL_DOT_PRODUCT_NV = _coin.GL_DOT_PRODUCT_NV
GL_DOT_PRODUCT_DEPTH_REPLACE_NV = _coin.GL_DOT_PRODUCT_DEPTH_REPLACE_NV
GL_DOT_PRODUCT_TEXTURE_2D_NV = _coin.GL_DOT_PRODUCT_TEXTURE_2D_NV
GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV = _coin.GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV
GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV = _coin.GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV
GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV = _coin.GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV
GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV = _coin.GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV
GL_HILO_NV = _coin.GL_HILO_NV
GL_DSDT_NV = _coin.GL_DSDT_NV
GL_DSDT_MAG_NV = _coin.GL_DSDT_MAG_NV
GL_DSDT_MAG_VIB_NV = _coin.GL_DSDT_MAG_VIB_NV
GL_HILO16_NV = _coin.GL_HILO16_NV
GL_SIGNED_HILO_NV = _coin.GL_SIGNED_HILO_NV
GL_SIGNED_HILO16_NV = _coin.GL_SIGNED_HILO16_NV
GL_SIGNED_RGBA_NV = _coin.GL_SIGNED_RGBA_NV
GL_SIGNED_RGBA8_NV = _coin.GL_SIGNED_RGBA8_NV
GL_SIGNED_RGB_NV = _coin.GL_SIGNED_RGB_NV
GL_SIGNED_RGB8_NV = _coin.GL_SIGNED_RGB8_NV
GL_SIGNED_LUMINANCE_NV = _coin.GL_SIGNED_LUMINANCE_NV
GL_SIGNED_LUMINANCE8_NV = _coin.GL_SIGNED_LUMINANCE8_NV
GL_SIGNED_LUMINANCE_ALPHA_NV = _coin.GL_SIGNED_LUMINANCE_ALPHA_NV
GL_SIGNED_LUMINANCE8_ALPHA8_NV = _coin.GL_SIGNED_LUMINANCE8_ALPHA8_NV
GL_SIGNED_ALPHA_NV = _coin.GL_SIGNED_ALPHA_NV
GL_SIGNED_ALPHA8_NV = _coin.GL_SIGNED_ALPHA8_NV
GL_SIGNED_INTENSITY_NV = _coin.GL_SIGNED_INTENSITY_NV
GL_SIGNED_INTENSITY8_NV = _coin.GL_SIGNED_INTENSITY8_NV
GL_DSDT8_NV = _coin.GL_DSDT8_NV
GL_DSDT8_MAG8_NV = _coin.GL_DSDT8_MAG8_NV
GL_DSDT8_MAG8_INTENSITY8_NV = _coin.GL_DSDT8_MAG8_INTENSITY8_NV
GL_SIGNED_RGB_UNSIGNED_ALPHA_NV = _coin.GL_SIGNED_RGB_UNSIGNED_ALPHA_NV
GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV = _coin.GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV
GL_HI_SCALE_NV = _coin.GL_HI_SCALE_NV
GL_LO_SCALE_NV = _coin.GL_LO_SCALE_NV
GL_DS_SCALE_NV = _coin.GL_DS_SCALE_NV
GL_DT_SCALE_NV = _coin.GL_DT_SCALE_NV
GL_MAGNITUDE_SCALE_NV = _coin.GL_MAGNITUDE_SCALE_NV
GL_VIBRANCE_SCALE_NV = _coin.GL_VIBRANCE_SCALE_NV
GL_HI_BIAS_NV = _coin.GL_HI_BIAS_NV
GL_LO_BIAS_NV = _coin.GL_LO_BIAS_NV
GL_DS_BIAS_NV = _coin.GL_DS_BIAS_NV
GL_DT_BIAS_NV = _coin.GL_DT_BIAS_NV
GL_MAGNITUDE_BIAS_NV = _coin.GL_MAGNITUDE_BIAS_NV
GL_VIBRANCE_BIAS_NV = _coin.GL_VIBRANCE_BIAS_NV
GL_TEXTURE_BORDER_VALUES_NV = _coin.GL_TEXTURE_BORDER_VALUES_NV
GL_TEXTURE_HI_SIZE_NV = _coin.GL_TEXTURE_HI_SIZE_NV
GL_TEXTURE_LO_SIZE_NV = _coin.GL_TEXTURE_LO_SIZE_NV
GL_TEXTURE_DS_SIZE_NV = _coin.GL_TEXTURE_DS_SIZE_NV
GL_TEXTURE_DT_SIZE_NV = _coin.GL_TEXTURE_DT_SIZE_NV
GL_TEXTURE_MAG_SIZE_NV = _coin.GL_TEXTURE_MAG_SIZE_NV
GL_NORMAL_MAP = _coin.GL_NORMAL_MAP
GL_REFLECTION_MAP = _coin.GL_REFLECTION_MAP
GL_TEXTURE_CUBE_MAP = _coin.GL_TEXTURE_CUBE_MAP
GL_TEXTURE_BINDING_CUBE_MAP = _coin.GL_TEXTURE_BINDING_CUBE_MAP
GL_TEXTURE_CUBE_MAP_POSITIVE_X = _coin.GL_TEXTURE_CUBE_MAP_POSITIVE_X
GL_TEXTURE_CUBE_MAP_NEGATIVE_X = _coin.GL_TEXTURE_CUBE_MAP_NEGATIVE_X
GL_TEXTURE_CUBE_MAP_POSITIVE_Y = _coin.GL_TEXTURE_CUBE_MAP_POSITIVE_Y
GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = _coin.GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
GL_TEXTURE_CUBE_MAP_POSITIVE_Z = _coin.GL_TEXTURE_CUBE_MAP_POSITIVE_Z
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = _coin.GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
GL_MAX_CUBE_MAP_TEXTURE_SIZE = _coin.GL_MAX_CUBE_MAP_TEXTURE_SIZE
GL_COMBINE = _coin.GL_COMBINE
GL_COMBINE_RGB = _coin.GL_COMBINE_RGB
GL_COMBINE_ALPHA = _coin.GL_COMBINE_ALPHA
GL_RGB_SCALE = _coin.GL_RGB_SCALE
GL_ADD_SIGNED = _coin.GL_ADD_SIGNED
GL_INTERPOLATE = _coin.GL_INTERPOLATE
GL_CONSTANT = _coin.GL_CONSTANT
GL_PRIMARY_COLOR = _coin.GL_PRIMARY_COLOR
GL_PREVIOUS = _coin.GL_PREVIOUS
GL_SOURCE0_RGB = _coin.GL_SOURCE0_RGB
GL_SOURCE1_RGB = _coin.GL_SOURCE1_RGB
GL_SOURCE2_RGB = _coin.GL_SOURCE2_RGB
GL_SOURCE0_ALPHA = _coin.GL_SOURCE0_ALPHA
GL_SOURCE1_ALPHA = _coin.GL_SOURCE1_ALPHA
GL_SOURCE2_ALPHA = _coin.GL_SOURCE2_ALPHA
GL_OPERAND0_RGB = _coin.GL_OPERAND0_RGB
GL_OPERAND1_RGB = _coin.GL_OPERAND1_RGB
GL_OPERAND2_RGB = _coin.GL_OPERAND2_RGB
GL_OPERAND0_ALPHA = _coin.GL_OPERAND0_ALPHA
GL_OPERAND1_ALPHA = _coin.GL_OPERAND1_ALPHA
GL_OPERAND2_ALPHA = _coin.GL_OPERAND2_ALPHA
GL_SUBTRACT = _coin.GL_SUBTRACT
GL_DOT3_RGB = _coin.GL_DOT3_RGB
GL_DOT3_RGBA = _coin.GL_DOT3_RGBA
GL_GENERATE_MIPMAP_SGIS = _coin.GL_GENERATE_MIPMAP_SGIS
GL_GENERATE_MIPMAP_HINT_SGIS = _coin.GL_GENERATE_MIPMAP_HINT_SGIS
GL_FRAGMENT_PROGRAM_ARB = _coin.GL_FRAGMENT_PROGRAM_ARB
GL_PROGRAM_FORMAT_ASCII_ARB = _coin.GL_PROGRAM_FORMAT_ASCII_ARB
GL_PROGRAM_LENGTH_ARB = _coin.GL_PROGRAM_LENGTH_ARB
GL_PROGRAM_FORMAT_ARB = _coin.GL_PROGRAM_FORMAT_ARB
GL_PROGRAM_BINDING_ARB = _coin.GL_PROGRAM_BINDING_ARB
GL_PROGRAM_INSTRUCTIONS_ARB = _coin.GL_PROGRAM_INSTRUCTIONS_ARB
GL_MAX_PROGRAM_INSTRUCTIONS_ARB = _coin.GL_MAX_PROGRAM_INSTRUCTIONS_ARB
GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB = _coin.GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB
GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = _coin.GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB
GL_PROGRAM_TEMPORARIES_ARB = _coin.GL_PROGRAM_TEMPORARIES_ARB
GL_MAX_PROGRAM_TEMPORARIES_ARB = _coin.GL_MAX_PROGRAM_TEMPORARIES_ARB
GL_PROGRAM_NATIVE_TEMPORARIES_ARB = _coin.GL_PROGRAM_NATIVE_TEMPORARIES_ARB
GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = _coin.GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB
GL_PROGRAM_PARAMETERS_ARB = _coin.GL_PROGRAM_PARAMETERS_ARB
GL_MAX_PROGRAM_PARAMETERS_ARB = _coin.GL_MAX_PROGRAM_PARAMETERS_ARB
GL_PROGRAM_NATIVE_PARAMETERS_ARB = _coin.GL_PROGRAM_NATIVE_PARAMETERS_ARB
GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB = _coin.GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB
GL_PROGRAM_ATTRIBS_ARB = _coin.GL_PROGRAM_ATTRIBS_ARB
GL_MAX_PROGRAM_ATTRIBS_ARB = _coin.GL_MAX_PROGRAM_ATTRIBS_ARB
GL_PROGRAM_NATIVE_ATTRIBS_ARB = _coin.GL_PROGRAM_NATIVE_ATTRIBS_ARB
GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB = _coin.GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB
GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB = _coin.GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB
GL_MAX_PROGRAM_ENV_PARAMETERS_ARB = _coin.GL_MAX_PROGRAM_ENV_PARAMETERS_ARB
GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB = _coin.GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB
GL_PROGRAM_ALU_INSTRUCTIONS_ARB = _coin.GL_PROGRAM_ALU_INSTRUCTIONS_ARB
GL_PROGRAM_TEX_INSTRUCTIONS_ARB = _coin.GL_PROGRAM_TEX_INSTRUCTIONS_ARB
GL_PROGRAM_TEX_INDIRECTIONS_ARB = _coin.GL_PROGRAM_TEX_INDIRECTIONS_ARB
GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = _coin.GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB
GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = _coin.GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB
GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = _coin.GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB
GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = _coin.GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB
GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = _coin.GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB
GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB = _coin.GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB
GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = _coin.GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB
GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = _coin.GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB
GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = _coin.GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB
GL_PROGRAM_STRING_ARB = _coin.GL_PROGRAM_STRING_ARB
GL_PROGRAM_ERROR_POSITION_ARB = _coin.GL_PROGRAM_ERROR_POSITION_ARB
GL_CURRENT_MATRIX_ARB = _coin.GL_CURRENT_MATRIX_ARB
GL_TRANSPOSE_CURRENT_MATRIX_ARB = _coin.GL_TRANSPOSE_CURRENT_MATRIX_ARB
GL_CURRENT_MATRIX_STACK_DEPTH_ARB = _coin.GL_CURRENT_MATRIX_STACK_DEPTH_ARB
GL_MAX_PROGRAM_MATRICES_ARB = _coin.GL_MAX_PROGRAM_MATRICES_ARB
GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = _coin.GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB
GL_MAX_TEXTURE_COORDS_ARB = _coin.GL_MAX_TEXTURE_COORDS_ARB
GL_MAX_TEXTURE_IMAGE_UNITS_ARB = _coin.GL_MAX_TEXTURE_IMAGE_UNITS_ARB
GL_PROGRAM_ERROR_STRING_ARB = _coin.GL_PROGRAM_ERROR_STRING_ARB
GL_MATRIX0_ARB = _coin.GL_MATRIX0_ARB
GL_MATRIX1_ARB = _coin.GL_MATRIX1_ARB
GL_MATRIX2_ARB = _coin.GL_MATRIX2_ARB
GL_MATRIX3_ARB = _coin.GL_MATRIX3_ARB
GL_MATRIX4_ARB = _coin.GL_MATRIX4_ARB
GL_MATRIX5_ARB = _coin.GL_MATRIX5_ARB
GL_MATRIX6_ARB = _coin.GL_MATRIX6_ARB
GL_MATRIX7_ARB = _coin.GL_MATRIX7_ARB
GL_MATRIX8_ARB = _coin.GL_MATRIX8_ARB
GL_MATRIX9_ARB = _coin.GL_MATRIX9_ARB
GL_MATRIX10_ARB = _coin.GL_MATRIX10_ARB
GL_MATRIX11_ARB = _coin.GL_MATRIX11_ARB
GL_MATRIX12_ARB = _coin.GL_MATRIX12_ARB
GL_MATRIX13_ARB = _coin.GL_MATRIX13_ARB
GL_MATRIX14_ARB = _coin.GL_MATRIX14_ARB
GL_MATRIX15_ARB = _coin.GL_MATRIX15_ARB
GL_MATRIX16_ARB = _coin.GL_MATRIX16_ARB
GL_MATRIX17_ARB = _coin.GL_MATRIX17_ARB
GL_MATRIX18_ARB = _coin.GL_MATRIX18_ARB
GL_MATRIX19_ARB = _coin.GL_MATRIX19_ARB
GL_MATRIX20_ARB = _coin.GL_MATRIX20_ARB
GL_MATRIX21_ARB = _coin.GL_MATRIX21_ARB
GL_MATRIX22_ARB = _coin.GL_MATRIX22_ARB
GL_MATRIX23_ARB = _coin.GL_MATRIX23_ARB
GL_MATRIX24_ARB = _coin.GL_MATRIX24_ARB
GL_MATRIX25_ARB = _coin.GL_MATRIX25_ARB
GL_MATRIX26_ARB = _coin.GL_MATRIX26_ARB
GL_MATRIX27_ARB = _coin.GL_MATRIX27_ARB
GL_MATRIX28_ARB = _coin.GL_MATRIX28_ARB
GL_MATRIX29_ARB = _coin.GL_MATRIX29_ARB
GL_MATRIX30_ARB = _coin.GL_MATRIX30_ARB
GL_MATRIX31_ARB = _coin.GL_MATRIX31_ARB
GL_VERTEX_PROGRAM_ARB = _coin.GL_VERTEX_PROGRAM_ARB
GL_VERTEX_PROGRAM_POINT_SIZE_ARB = _coin.GL_VERTEX_PROGRAM_POINT_SIZE_ARB
GL_VERTEX_PROGRAM_TWO_SIDE_ARB = _coin.GL_VERTEX_PROGRAM_TWO_SIDE_ARB
GL_COLOR_SUM_ARB = _coin.GL_COLOR_SUM_ARB
GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB = _coin.GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB
GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB = _coin.GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB
GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB = _coin.GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB
GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB = _coin.GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB
GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = _coin.GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB
GL_CURRENT_VERTEX_ATTRIB_ARB = _coin.GL_CURRENT_VERTEX_ATTRIB_ARB
GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB = _coin.GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB
GL_PROGRAM_ADDRESS_REGISTERS_ARB = _coin.GL_PROGRAM_ADDRESS_REGISTERS_ARB
GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB = _coin.GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB
GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = _coin.GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB
GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = _coin.GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB
GL_MAX_VERTEX_ATTRIBS_ARB = _coin.GL_MAX_VERTEX_ATTRIBS_ARB
GL_VERTEX_SHADER_ARB = _coin.GL_VERTEX_SHADER_ARB
GL_FRAGMENT_SHADER_ARB = _coin.GL_FRAGMENT_SHADER_ARB
GL_OBJECT_ACTIVE_UNIFORMS_ARB = _coin.GL_OBJECT_ACTIVE_UNIFORMS_ARB
GL_GEOMETRY_SHADER_EXT = _coin.GL_GEOMETRY_SHADER_EXT
GL_GEOMETRY_VERTICES_OUT_EXT = _coin.GL_GEOMETRY_VERTICES_OUT_EXT
GL_GEOMETRY_INPUT_TYPE_EXT = _coin.GL_GEOMETRY_INPUT_TYPE_EXT
GL_GEOMETRY_OUTPUT_TYPE_EXT = _coin.GL_GEOMETRY_OUTPUT_TYPE_EXT
GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT = _coin.GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT
GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT = _coin.GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT
GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT = _coin.GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT
GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT = _coin.GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT
GL_MAX_VERTEX_VARYING_COMPONENTS_EXT = _coin.GL_MAX_VERTEX_VARYING_COMPONENTS_EXT
GL_MAX_VARYING_COMPONENTS_EXT = _coin.GL_MAX_VARYING_COMPONENTS_EXT
GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT = _coin.GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT
GL_INT_VEC2_ARB = _coin.GL_INT_VEC2_ARB
GL_INT_VEC3_ARB = _coin.GL_INT_VEC3_ARB
GL_INT_VEC4_ARB = _coin.GL_INT_VEC4_ARB
GL_FLOAT_VEC2_ARB = _coin.GL_FLOAT_VEC2_ARB
GL_FLOAT_VEC3_ARB = _coin.GL_FLOAT_VEC3_ARB
GL_FLOAT_VEC4_ARB = _coin.GL_FLOAT_VEC4_ARB
GL_FLOAT_MAT2_ARB = _coin.GL_FLOAT_MAT2_ARB
GL_FLOAT_MAT3_ARB = _coin.GL_FLOAT_MAT3_ARB
GL_FLOAT_MAT4_ARB = _coin.GL_FLOAT_MAT4_ARB
GL_SAMPLER_1D_ARB = _coin.GL_SAMPLER_1D_ARB
GL_SAMPLER_2D_ARB = _coin.GL_SAMPLER_2D_ARB
GL_SAMPLER_3D_ARB = _coin.GL_SAMPLER_3D_ARB
GL_SAMPLER_CUBE_ARB = _coin.GL_SAMPLER_CUBE_ARB
GL_SAMPLER_1D_SHADOW_ARB = _coin.GL_SAMPLER_1D_SHADOW_ARB
GL_SAMPLER_2D_SHADOW_ARB = _coin.GL_SAMPLER_2D_SHADOW_ARB
GL_SAMPLER_2D_RECT_ARB = _coin.GL_SAMPLER_2D_RECT_ARB
GL_SAMPLER_2D_RECT_SHADOW_ARB = _coin.GL_SAMPLER_2D_RECT_SHADOW_ARB
GL_OBJECT_COMPILE_STATUS_ARB = _coin.GL_OBJECT_COMPILE_STATUS_ARB
GL_OBJECT_INFO_LOG_LENGTH_ARB = _coin.GL_OBJECT_INFO_LOG_LENGTH_ARB
GL_OBJECT_LINK_STATUS_ARB = _coin.GL_OBJECT_LINK_STATUS_ARB
GL_TEXTURE_MAX_ANISOTROPY_EXT = _coin.GL_TEXTURE_MAX_ANISOTROPY_EXT
GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = _coin.GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT
GL_SAMPLES_PASSED = _coin.GL_SAMPLES_PASSED
GL_QUERY_COUNTER_BITS = _coin.GL_QUERY_COUNTER_BITS
GL_CURRENT_QUERY = _coin.GL_CURRENT_QUERY
GL_QUERY_RESULT = _coin.GL_QUERY_RESULT
GL_QUERY_RESULT_AVAILABLE = _coin.GL_QUERY_RESULT_AVAILABLE
GL_CLIENT_PIXEL_STORE_BIT = _coin.GL_CLIENT_PIXEL_STORE_BIT
GL_CLIENT_VERTEX_ARRAY_BIT = _coin.GL_CLIENT_VERTEX_ARRAY_BIT
GL_CLIENT_ALL_ATTRIB_BITS = _coin.GL_CLIENT_ALL_ATTRIB_BITS
GL_ALL_CLIENT_ATTRIB_BITS = _coin.GL_ALL_CLIENT_ATTRIB_BITS
GL_INVALID_FRAMEBUFFER_OPERATION_EXT = _coin.GL_INVALID_FRAMEBUFFER_OPERATION_EXT
GL_MAX_RENDERBUFFER_SIZE_EXT = _coin.GL_MAX_RENDERBUFFER_SIZE_EXT
GL_FRAMEBUFFER_BINDING_EXT = _coin.GL_FRAMEBUFFER_BINDING_EXT
GL_RENDERBUFFER_BINDING_EXT = _coin.GL_RENDERBUFFER_BINDING_EXT
GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT = _coin.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT
GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT = _coin.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT = _coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT = _coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT = _coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT
GL_FRAMEBUFFER_COMPLETE_EXT = _coin.GL_FRAMEBUFFER_COMPLETE_EXT
GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT = _coin.GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT
GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT = _coin.GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT
GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT = _coin.GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT
GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT = _coin.GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT
GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT = _coin.GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT
GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT = _coin.GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT
GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT = _coin.GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT
GL_FRAMEBUFFER_UNSUPPORTED_EXT = _coin.GL_FRAMEBUFFER_UNSUPPORTED_EXT
GL_MAX_COLOR_ATTACHMENTS_EXT = _coin.GL_MAX_COLOR_ATTACHMENTS_EXT
GL_COLOR_ATTACHMENT0_EXT = _coin.GL_COLOR_ATTACHMENT0_EXT
GL_COLOR_ATTACHMENT1_EXT = _coin.GL_COLOR_ATTACHMENT1_EXT
GL_COLOR_ATTACHMENT2_EXT = _coin.GL_COLOR_ATTACHMENT2_EXT
GL_COLOR_ATTACHMENT3_EXT = _coin.GL_COLOR_ATTACHMENT3_EXT
GL_COLOR_ATTACHMENT4_EXT = _coin.GL_COLOR_ATTACHMENT4_EXT
GL_COLOR_ATTACHMENT5_EXT = _coin.GL_COLOR_ATTACHMENT5_EXT
GL_COLOR_ATTACHMENT6_EXT = _coin.GL_COLOR_ATTACHMENT6_EXT
GL_COLOR_ATTACHMENT7_EXT = _coin.GL_COLOR_ATTACHMENT7_EXT
GL_COLOR_ATTACHMENT8_EXT = _coin.GL_COLOR_ATTACHMENT8_EXT
GL_COLOR_ATTACHMENT9_EXT = _coin.GL_COLOR_ATTACHMENT9_EXT
GL_COLOR_ATTACHMENT10_EXT = _coin.GL_COLOR_ATTACHMENT10_EXT
GL_COLOR_ATTACHMENT11_EXT = _coin.GL_COLOR_ATTACHMENT11_EXT
GL_COLOR_ATTACHMENT12_EXT = _coin.GL_COLOR_ATTACHMENT12_EXT
GL_COLOR_ATTACHMENT13_EXT = _coin.GL_COLOR_ATTACHMENT13_EXT
GL_COLOR_ATTACHMENT14_EXT = _coin.GL_COLOR_ATTACHMENT14_EXT
GL_COLOR_ATTACHMENT15_EXT = _coin.GL_COLOR_ATTACHMENT15_EXT
GL_DEPTH_ATTACHMENT_EXT = _coin.GL_DEPTH_ATTACHMENT_EXT
GL_STENCIL_ATTACHMENT_EXT = _coin.GL_STENCIL_ATTACHMENT_EXT
GL_FRAMEBUFFER_EXT = _coin.GL_FRAMEBUFFER_EXT
GL_RENDERBUFFER_EXT = _coin.GL_RENDERBUFFER_EXT
GL_RENDERBUFFER_WIDTH_EXT = _coin.GL_RENDERBUFFER_WIDTH_EXT
GL_RENDERBUFFER_HEIGHT_EXT = _coin.GL_RENDERBUFFER_HEIGHT_EXT
GL_RENDERBUFFER_INTERNAL_FORMAT_EXT = _coin.GL_RENDERBUFFER_INTERNAL_FORMAT_EXT
GL_STENCIL_INDEX1_EXT = _coin.GL_STENCIL_INDEX1_EXT
GL_STENCIL_INDEX4_EXT = _coin.GL_STENCIL_INDEX4_EXT
GL_STENCIL_INDEX8_EXT = _coin.GL_STENCIL_INDEX8_EXT
GL_STENCIL_INDEX16_EXT = _coin.GL_STENCIL_INDEX16_EXT
GL_RENDERBUFFER_RED_SIZE_EXT = _coin.GL_RENDERBUFFER_RED_SIZE_EXT
GL_RENDERBUFFER_GREEN_SIZE_EXT = _coin.GL_RENDERBUFFER_GREEN_SIZE_EXT
GL_RENDERBUFFER_BLUE_SIZE_EXT = _coin.GL_RENDERBUFFER_BLUE_SIZE_EXT
GL_RENDERBUFFER_ALPHA_SIZE_EXT = _coin.GL_RENDERBUFFER_ALPHA_SIZE_EXT
GL_RENDERBUFFER_DEPTH_SIZE_EXT = _coin.GL_RENDERBUFFER_DEPTH_SIZE_EXT
GL_RENDERBUFFER_STENCIL_SIZE_EXT = _coin.GL_RENDERBUFFER_STENCIL_SIZE_EXT
GL_INVALID_FRAMEBUFFER_OPERATION = _coin.GL_INVALID_FRAMEBUFFER_OPERATION
GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = _coin.GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING
GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = _coin.GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE
GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE = _coin.GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE
GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = _coin.GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE
GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = _coin.GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE
GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = _coin.GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE
GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = _coin.GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE
GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = _coin.GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE
GL_DEPTH_STENCIL = _coin.GL_DEPTH_STENCIL
GL_UNSIGNED_INT_24_ = _coin.GL_UNSIGNED_INT_24_
GL_DEPTH24_STENCIL8 = _coin.GL_DEPTH24_STENCIL8
GL_TEXTURE_STENCIL_SIZE = _coin.GL_TEXTURE_STENCIL_SIZE
GL_SRGB = _coin.GL_SRGB
GL_UNSIGNED_NORMALIZED = _coin.GL_UNSIGNED_NORMALIZED
GL_FRAMEBUFFER_DEFAULT = _coin.GL_FRAMEBUFFER_DEFAULT
GL_FRAMEBUFFER_UNDEFINED = _coin.GL_FRAMEBUFFER_UNDEFINED
GL_DEPTH_STENCIL_ATTACHMENT = _coin.GL_DEPTH_STENCIL_ATTACHMENT
GL_INDEX = _coin.GL_INDEX
GL_MAX_RENDERBUFFER_SIZE = _coin.GL_MAX_RENDERBUFFER_SIZE
GL_FRAMEBUFFER_BINDING = _coin.GL_FRAMEBUFFER_BINDING
GL_DRAW_FRAMEBUFFER_BINDING = _coin.GL_DRAW_FRAMEBUFFER_BINDING
GL_RENDERBUFFER_BINDING = _coin.GL_RENDERBUFFER_BINDING
GL_READ_FRAMEBUFFER = _coin.GL_READ_FRAMEBUFFER
GL_DRAW_FRAMEBUFFER = _coin.GL_DRAW_FRAMEBUFFER
GL_READ_FRAMEBUFFER_BINDING = _coin.GL_READ_FRAMEBUFFER_BINDING
GL_RENDERBUFFER_SAMPLES = _coin.GL_RENDERBUFFER_SAMPLES
GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = _coin.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE
GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = _coin.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = _coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = _coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = _coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET = _coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET
GL_FRAMEBUFFER_COMPLETE = _coin.GL_FRAMEBUFFER_COMPLETE
GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = _coin.GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT
GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = _coin.GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT
GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT = _coin.GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT
GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = _coin.GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER
GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER = _coin.GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER
GL_FRAMEBUFFER_UNSUPPORTED = _coin.GL_FRAMEBUFFER_UNSUPPORTED
GL_MAX_COLOR_ATTACHMENTS = _coin.GL_MAX_COLOR_ATTACHMENTS
GL_COLOR_ATTACHMENT0 = _coin.GL_COLOR_ATTACHMENT0
GL_COLOR_ATTACHMENT1 = _coin.GL_COLOR_ATTACHMENT1
GL_COLOR_ATTACHMENT2 = _coin.GL_COLOR_ATTACHMENT2
GL_COLOR_ATTACHMENT3 = _coin.GL_COLOR_ATTACHMENT3
GL_COLOR_ATTACHMENT4 = _coin.GL_COLOR_ATTACHMENT4
GL_COLOR_ATTACHMENT5 = _coin.GL_COLOR_ATTACHMENT5
GL_COLOR_ATTACHMENT6 = _coin.GL_COLOR_ATTACHMENT6
GL_COLOR_ATTACHMENT7 = _coin.GL_COLOR_ATTACHMENT7
GL_COLOR_ATTACHMENT8 = _coin.GL_COLOR_ATTACHMENT8
GL_COLOR_ATTACHMENT9 = _coin.GL_COLOR_ATTACHMENT9
GL_COLOR_ATTACHMENT10 = _coin.GL_COLOR_ATTACHMENT10
GL_COLOR_ATTACHMENT11 = _coin.GL_COLOR_ATTACHMENT11
GL_COLOR_ATTACHMENT12 = _coin.GL_COLOR_ATTACHMENT12
GL_COLOR_ATTACHMENT13 = _coin.GL_COLOR_ATTACHMENT13
GL_COLOR_ATTACHMENT14 = _coin.GL_COLOR_ATTACHMENT14
GL_COLOR_ATTACHMENT15 = _coin.GL_COLOR_ATTACHMENT15
GL_DEPTH_ATTACHMENT = _coin.GL_DEPTH_ATTACHMENT
GL_STENCIL_ATTACHMENT = _coin.GL_STENCIL_ATTACHMENT
GL_FRAMEBUFFER = _coin.GL_FRAMEBUFFER
GL_RENDERBUFFER = _coin.GL_RENDERBUFFER
GL_RENDERBUFFER_WIDTH = _coin.GL_RENDERBUFFER_WIDTH
GL_RENDERBUFFER_HEIGHT = _coin.GL_RENDERBUFFER_HEIGHT
GL_RENDERBUFFER_INTERNAL_FORMAT = _coin.GL_RENDERBUFFER_INTERNAL_FORMAT
GL_STENCIL_INDEX1 = _coin.GL_STENCIL_INDEX1
GL_STENCIL_INDEX4 = _coin.GL_STENCIL_INDEX4
GL_STENCIL_INDEX8 = _coin.GL_STENCIL_INDEX8
GL_STENCIL_INDEX16 = _coin.GL_STENCIL_INDEX16
GL_RENDERBUFFER_RED_SIZE = _coin.GL_RENDERBUFFER_RED_SIZE
GL_RENDERBUFFER_GREEN_SIZE = _coin.GL_RENDERBUFFER_GREEN_SIZE
GL_RENDERBUFFER_BLUE_SIZE = _coin.GL_RENDERBUFFER_BLUE_SIZE
GL_RENDERBUFFER_ALPHA_SIZE = _coin.GL_RENDERBUFFER_ALPHA_SIZE
GL_RENDERBUFFER_DEPTH_SIZE = _coin.GL_RENDERBUFFER_DEPTH_SIZE
GL_RENDERBUFFER_STENCIL_SIZE = _coin.GL_RENDERBUFFER_STENCIL_SIZE
GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = _coin.GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE
GL_MAX_SAMPLES = _coin.GL_MAX_SAMPLES
GLX_PBUFFER_WIDTH = _coin.GLX_PBUFFER_WIDTH
GLX_PBUFFER_HEIGHT = _coin.GLX_PBUFFER_HEIGHT
GLX_DRAWABLE_TYPE = _coin.GLX_DRAWABLE_TYPE
GLX_RENDER_TYPE = _coin.GLX_RENDER_TYPE
GLX_RGBA_TYPE = _coin.GLX_RGBA_TYPE
GLX_RGBA_BIT = _coin.GLX_RGBA_BIT
GLX_PBUFFER_BIT = _coin.GLX_PBUFFER_BIT
GLX_MAX_PBUFFER_WIDTH = _coin.GLX_MAX_PBUFFER_WIDTH
GLX_MAX_PBUFFER_HEIGHT = _coin.GLX_MAX_PBUFFER_HEIGHT
GLX_MAX_PBUFFER_PIXELS = _coin.GLX_MAX_PBUFFER_PIXELS
GLU_VERSION = _coin.GLU_VERSION
GLU_EXTENSIONS = _coin.GLU_EXTENSIONS
GLU_OUTLINE_POLYGON = _coin.GLU_OUTLINE_POLYGON
GLU_OUTLINE_PATCH = _coin.GLU_OUTLINE_PATCH
GLU_NURBS_ERROR = _coin.GLU_NURBS_ERROR
GLU_ERROR = _coin.GLU_ERROR
GLU_NURBS_BEGIN = _coin.GLU_NURBS_BEGIN
GLU_NURBS_VERTEX = _coin.GLU_NURBS_VERTEX
GLU_NURBS_NORMAL = _coin.GLU_NURBS_NORMAL
GLU_NURBS_COLOR = _coin.GLU_NURBS_COLOR
GLU_NURBS_TEXTURE_COORD = _coin.GLU_NURBS_TEXTURE_COORD
GLU_NURBS_END = _coin.GLU_NURBS_END
GLU_NURBS_BEGIN_DATA = _coin.GLU_NURBS_BEGIN_DATA
GLU_NURBS_VERTEX_DATA = _coin.GLU_NURBS_VERTEX_DATA
GLU_NURBS_NORMAL_DATA = _coin.GLU_NURBS_NORMAL_DATA
GLU_NURBS_COLOR_DATA = _coin.GLU_NURBS_COLOR_DATA
GLU_NURBS_TEXTURE_COORD_DATA = _coin.GLU_NURBS_TEXTURE_COORD_DATA
GLU_NURBS_END_DATA = _coin.GLU_NURBS_END_DATA
GLU_AUTO_LOAD_MATRIX = _coin.GLU_AUTO_LOAD_MATRIX
GLU_CULLING = _coin.GLU_CULLING
GLU_SAMPLING_TOLERANCE = _coin.GLU_SAMPLING_TOLERANCE
GLU_DISPLAY_MODE = _coin.GLU_DISPLAY_MODE
GLU_PARAMETRIC_TOLERANCE = _coin.GLU_PARAMETRIC_TOLERANCE
GLU_SAMPLING_METHOD = _coin.GLU_SAMPLING_METHOD
GLU_U_STEP = _coin.GLU_U_STEP
GLU_V_STEP = _coin.GLU_V_STEP
GLU_NURBS_MODE = _coin.GLU_NURBS_MODE
GLU_NURBS_TESSELLATOR = _coin.GLU_NURBS_TESSELLATOR
GLU_NURBS_RENDERER = _coin.GLU_NURBS_RENDERER
GLU_OBJECT_PARAMETRIC_ERROR = _coin.GLU_OBJECT_PARAMETRIC_ERROR
GLU_OBJECT_PATH_LENGTH = _coin.GLU_OBJECT_PATH_LENGTH
GLU_PATH_LENGTH = _coin.GLU_PATH_LENGTH
GLU_PARAMETRIC_ERROR = _coin.GLU_PARAMETRIC_ERROR
GLU_DOMAIN_DISTANCE = _coin.GLU_DOMAIN_DISTANCE
GLU_MAP1_TRIM_2 = _coin.GLU_MAP1_TRIM_2
GLU_MAP1_TRIM_3 = _coin.GLU_MAP1_TRIM_3
GLU_POINT = _coin.GLU_POINT
GLU_LINE = _coin.GLU_LINE
GLU_FILL = _coin.GLU_FILL
GLU_SILHOUETTE = _coin.GLU_SILHOUETTE
GLU_TESS_BEGIN = _coin.GLU_TESS_BEGIN
GLU_TESS_VERTEX = _coin.GLU_TESS_VERTEX
GLU_TESS_END = _coin.GLU_TESS_END
GLU_TESS_ERROR = _coin.GLU_TESS_ERROR
GLU_TESS_COMBINE = _coin.GLU_TESS_COMBINE
GLU_TESS_BEGIN_DATA = _coin.GLU_TESS_BEGIN_DATA
GLU_TESS_VERTEX_DATA = _coin.GLU_TESS_VERTEX_DATA
GLU_TESS_END_DATA = _coin.GLU_TESS_END_DATA
GLU_TESS_ERROR_DATA = _coin.GLU_TESS_ERROR_DATA
GLU_TESS_MISSING_BEGIN_POLYGON = _coin.GLU_TESS_MISSING_BEGIN_POLYGON
GLU_TESS_MISSING_BEGIN_CONTOUR = _coin.GLU_TESS_MISSING_BEGIN_CONTOUR
GLU_TESS_MISSING_END_POLYGON = _coin.GLU_TESS_MISSING_END_POLYGON
GLU_TESS_MISSING_END_CONTOUR = _coin.GLU_TESS_MISSING_END_CONTOUR
GLU_TESS_NEED_COMBINE_CALLBACK = _coin.GLU_TESS_NEED_COMBINE_CALLBACK
WGL_COLOR_BITS_ARB = _coin.WGL_COLOR_BITS_ARB
WGL_ALPHA_BITS_ARB = _coin.WGL_ALPHA_BITS_ARB
WGL_DEPTH_BITS_ARB = _coin.WGL_DEPTH_BITS_ARB
WGL_STENCIL_BITS_ARB = _coin.WGL_STENCIL_BITS_ARB
WGL_DRAW_TO_PBUFFER_ARB = _coin.WGL_DRAW_TO_PBUFFER_ARB
WGL_PBUFFER_WIDTH_ARB = _coin.WGL_PBUFFER_WIDTH_ARB
WGL_PBUFFER_HEIGHT_ARB = _coin.WGL_PBUFFER_HEIGHT_ARB
WGL_BIND_TO_TEXTURE_RGB_ARB = _coin.WGL_BIND_TO_TEXTURE_RGB_ARB
WGL_BIND_TO_TEXTURE_RGBA_ARB = _coin.WGL_BIND_TO_TEXTURE_RGBA_ARB
WGL_TEXTURE_FORMAT_ARB = _coin.WGL_TEXTURE_FORMAT_ARB
WGL_TEXTURE_TARGET_ARB = _coin.WGL_TEXTURE_TARGET_ARB
WGL_MIPMAP_TEXTURE_ARB = _coin.WGL_MIPMAP_TEXTURE_ARB
WGL_TEXTURE_RGB_ARB = _coin.WGL_TEXTURE_RGB_ARB
WGL_TEXTURE_RGBA_ARB = _coin.WGL_TEXTURE_RGBA_ARB
WGL_NO_TEXTURE_ARB = _coin.WGL_NO_TEXTURE_ARB
WGL_TEXTURE_CUBE_MAP_ARB = _coin.WGL_TEXTURE_CUBE_MAP_ARB
WGL_TEXTURE_1D_ARB = _coin.WGL_TEXTURE_1D_ARB
WGL_TEXTURE_2D_ARB = _coin.WGL_TEXTURE_2D_ARB
WGL_MIPMAP_LEVEL_ARB = _coin.WGL_MIPMAP_LEVEL_ARB
WGL_FRONT_LEFT_ARB = _coin.WGL_FRONT_LEFT_ARB
WGL_FRONT_RIGHT_ARB = _coin.WGL_FRONT_RIGHT_ARB
WGL_BACK_LEFT_ARB = _coin.WGL_BACK_LEFT_ARB
WGL_BACK_RIGHT_ARB = _coin.WGL_BACK_RIGHT_ARB
WGL_MAX_PBUFFER_PIXELS_ARB = _coin.WGL_MAX_PBUFFER_PIXELS_ARB
WGL_MAX_PBUFFER_WIDTH_ARB = _coin.WGL_MAX_PBUFFER_WIDTH_ARB
WGL_MAX_PBUFFER_HEIGHT_ARB = _coin.WGL_MAX_PBUFFER_HEIGHT_ARB
class SbBarrier(object):
    """Proxy of C++ SbBarrier class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, unsigned int count) -> SbBarrier"""
        this = _coin.new_SbBarrier(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SbBarrier
    __del__ = lambda self : None;
    def enter(self):
        """enter(self) -> int"""
        return _coin.SbBarrier_enter(self)

SbBarrier_swigregister = _coin.SbBarrier_swigregister
SbBarrier_swigregister(SbBarrier)

class SbMutex(object):
    """Proxy of C++ SbMutex class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SbMutex"""
        this = _coin.new_SbMutex()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SbMutex
    __del__ = lambda self : None;
    def lock(self):
        """lock(self) -> int"""
        return _coin.SbMutex_lock(self)

    def tryLock(self):
        """tryLock(self) -> SbBool"""
        return _coin.SbMutex_tryLock(self)

    def unlock(self):
        """unlock(self) -> int"""
        return _coin.SbMutex_unlock(self)

SbMutex_swigregister = _coin.SbMutex_swigregister
SbMutex_swigregister(SbMutex)

class SbThreadMutex(object):
    """Proxy of C++ SbThreadMutex class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SbThreadMutex"""
        this = _coin.new_SbThreadMutex()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SbThreadMutex
    __del__ = lambda self : None;
    def lock(self):
        """lock(self) -> int"""
        return _coin.SbThreadMutex_lock(self)

    def tryLock(self):
        """tryLock(self) -> SbBool"""
        return _coin.SbThreadMutex_tryLock(self)

    def unlock(self):
        """unlock(self) -> int"""
        return _coin.SbThreadMutex_unlock(self)

SbThreadMutex_swigregister = _coin.SbThreadMutex_swigregister
SbThreadMutex_swigregister(SbThreadMutex)

class SbThreadAutoLock(object):
    """Proxy of C++ SbThreadAutoLock class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, SbMutex mutexptr) -> SbThreadAutoLock
        __init__(self, SbThreadMutex mutexptr) -> SbThreadAutoLock
        """
        this = _coin.new_SbThreadAutoLock(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SbThreadAutoLock
    __del__ = lambda self : None;
SbThreadAutoLock_swigregister = _coin.SbThreadAutoLock_swigregister
SbThreadAutoLock_swigregister(SbThreadAutoLock)

class SbCondVar(object):
    """Proxy of C++ SbCondVar class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SbCondVar"""
        this = _coin.new_SbCondVar()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SbCondVar
    __del__ = lambda self : None;
    def wait(self, *args):
        """wait(self, SbMutex mutex) -> SbBool"""
        return _coin.SbCondVar_wait(self, *args)

    def timedWait(self, *args):
        """timedWait(self, SbMutex mutex, SbTime period) -> SbBool"""
        return _coin.SbCondVar_timedWait(self, *args)

    def wakeOne(self):
        """wakeOne(self)"""
        return _coin.SbCondVar_wakeOne(self)

    def wakeAll(self):
        """wakeAll(self)"""
        return _coin.SbCondVar_wakeAll(self)

SbCondVar_swigregister = _coin.SbCondVar_swigregister
SbCondVar_swigregister(SbCondVar)

class SbFifo(object):
    """Proxy of C++ SbFifo class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SbFifo"""
        this = _coin.new_SbFifo()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SbFifo
    __del__ = lambda self : None;
    def assign(self, *args):
        """assign(self, void ptr, uint32_t type)"""
        return _coin.SbFifo_assign(self, *args)

    def retrieve(self, *args):
        """retrieve(self, void ptr, uint32_t type)"""
        return _coin.SbFifo_retrieve(self, *args)

    def tryRetrieve(self, *args):
        """tryRetrieve(self, void ptr, uint32_t type) -> SbBool"""
        return _coin.SbFifo_tryRetrieve(self, *args)

    def size(self):
        """size(self) -> unsigned int"""
        return _coin.SbFifo_size(self)

    def lock(self):
        """lock(self)"""
        return _coin.SbFifo_lock(self)

    def unlock(self):
        """unlock(self)"""
        return _coin.SbFifo_unlock(self)

    def peek(self, *args):
        """peek(self, void item, uint32_t type) -> SbBool"""
        return _coin.SbFifo_peek(self, *args)

    def contains(self, *args):
        """contains(self, void item) -> SbBool"""
        return _coin.SbFifo_contains(self, *args)

    def reclaim(self, *args):
        """reclaim(self, void item) -> SbBool"""
        return _coin.SbFifo_reclaim(self, *args)

SbFifo_swigregister = _coin.SbFifo_swigregister
SbFifo_swigregister(SbFifo)

class SbRWMutex(object):
    """Proxy of C++ SbRWMutex class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    READ_PRECEDENCE = _coin.SbRWMutex_READ_PRECEDENCE
    WRITE_PRECEDENCE = _coin.SbRWMutex_WRITE_PRECEDENCE
    def __init__(self, *args): 
        """__init__(self, Precedence policy) -> SbRWMutex"""
        this = _coin.new_SbRWMutex(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SbRWMutex
    __del__ = lambda self : None;
    def writeLock(self):
        """writeLock(self) -> int"""
        return _coin.SbRWMutex_writeLock(self)

    def tryWriteLock(self):
        """tryWriteLock(self) -> SbBool"""
        return _coin.SbRWMutex_tryWriteLock(self)

    def writeUnlock(self):
        """writeUnlock(self) -> int"""
        return _coin.SbRWMutex_writeUnlock(self)

    def readLock(self):
        """readLock(self) -> int"""
        return _coin.SbRWMutex_readLock(self)

    def tryReadLock(self):
        """tryReadLock(self) -> int"""
        return _coin.SbRWMutex_tryReadLock(self)

    def readUnlock(self):
        """readUnlock(self) -> int"""
        return _coin.SbRWMutex_readUnlock(self)

SbRWMutex_swigregister = _coin.SbRWMutex_swigregister
SbRWMutex_swigregister(SbRWMutex)

class SbStorage(object):
    """Proxy of C++ SbStorage class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, unsigned int size) -> SbStorage
        __init__(self, unsigned int size, cc_storage_f constr, cc_storage_f destr) -> SbStorage
        """
        this = _coin.new_SbStorage(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SbStorage
    __del__ = lambda self : None;
    def get(self):
        """get(self) -> void"""
        return _coin.SbStorage_get(self)

    def applyToAll(self, *args):
        """applyToAll(self, SbStorageApplyFunc func, void closure)"""
        return _coin.SbStorage_applyToAll(self, *args)

SbStorage_swigregister = _coin.SbStorage_swigregister
SbStorage_swigregister(SbStorage)

class SbThread(object):
    """Proxy of C++ SbThread class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def create(*args):
        """create(void func, void closure) -> SbThread"""
        return _coin.SbThread_create(*args)

    create = staticmethod(create)
    def destroy(*args):
        """destroy(SbThread thread)"""
        return _coin.SbThread_destroy(*args)

    destroy = staticmethod(destroy)
    def join(*args):
        """
        join(void retval = 0L) -> SbBool
        join() -> SbBool
        join(SbThread thread, void retval = 0L) -> SbBool
        join(SbThread thread) -> SbBool
        """
        return _coin.SbThread_join(*args)

    join = staticmethod(join)
SbThread_swigregister = _coin.SbThread_swigregister
SbThread_swigregister(SbThread)

def SbThread_create(*args):
  """SbThread_create(void func, void closure) -> SbThread"""
  return _coin.SbThread_create(*args)

def SbThread_destroy(*args):
  """SbThread_destroy(SbThread thread)"""
  return _coin.SbThread_destroy(*args)

def SbThread_join(*args):
  """
    join(void retval = 0L) -> SbBool
    join() -> SbBool
    join(SbThread thread, void retval = 0L) -> SbBool
    SbThread_join(SbThread thread) -> SbBool
    """
  return _coin.SbThread_join(*args)

class SoVRMLParent(SoGroup):
    """Proxy of C++ SoVRMLParent class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLParent_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLParent_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLParent_initClass()

    initClass = staticmethod(initClass)
    children = _swig_property(_coin.SoVRMLParent_children_get, _coin.SoVRMLParent_children_set)
    def affectsState(self):
        """affectsState(self) -> SbBool"""
        return _coin.SoVRMLParent_affectsState(self)

    def addChild(self, *args):
        """addChild(self, SoNode child)"""
        return _coin.SoVRMLParent_addChild(self, *args)

    def insertChild(self, *args):
        """insertChild(self, SoNode child, int idx)"""
        return _coin.SoVRMLParent_insertChild(self, *args)

    def getChild(self, *args):
        """getChild(self, int idx) -> SoNode"""
        return _coin.SoVRMLParent_getChild(self, *args)

    def findChild(self, *args):
        """findChild(self, SoNode child) -> int"""
        return _coin.SoVRMLParent_findChild(self, *args)

    def getNumChildren(self):
        """getNumChildren(self) -> int"""
        return _coin.SoVRMLParent_getNumChildren(self)

    def removeChild(self, *args):
        """
        removeChild(self, int idx)
        removeChild(self, SoNode child)
        """
        return _coin.SoVRMLParent_removeChild(self, *args)

    def removeAllChildren(self):
        """removeAllChildren(self)"""
        return _coin.SoVRMLParent_removeAllChildren(self)

    def replaceChild(self, *args):
        """
        replaceChild(self, int idx, SoNode child)
        replaceChild(self, SoNode old, SoNode child)
        """
        return _coin.SoVRMLParent_replaceChild(self, *args)

    def getChildren(self):
        """getChildren(self) -> SoChildList"""
        return _coin.SoVRMLParent_getChildren(self)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoVRMLParent_doAction(self, *args)

    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoVRMLParent_search(self, *args)

    def write(self, *args):
        """write(self, SoWriteAction action)"""
        return _coin.SoVRMLParent_write(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLParent_getPrimitiveCount(self, *args)

    def updateChildList(*args):
        """
        updateChildList(SoNode nodes, int numnodes, SoChildList cl)
        updateChildList(SoNode nodewithsfnode, SoChildList cl)
        """
        return _coin.SoVRMLParent_updateChildList(*args)

    updateChildList = staticmethod(updateChildList)
SoVRMLParent_swigregister = _coin.SoVRMLParent_swigregister
SoVRMLParent_swigregister(SoVRMLParent)

def SoVRMLParent_getClassTypeId():
  """SoVRMLParent_getClassTypeId() -> SoType"""
  return _coin.SoVRMLParent_getClassTypeId()

def SoVRMLParent_initClass():
  """SoVRMLParent_initClass()"""
  return _coin.SoVRMLParent_initClass()

def SoVRMLParent_updateChildList(*args):
  """
    updateChildList(SoNode nodes, int numnodes, SoChildList cl)
    SoVRMLParent_updateChildList(SoNode nodewithsfnode, SoChildList cl)
    """
  return _coin.SoVRMLParent_updateChildList(*args)

class SoVRMLAnchor(SoVRMLParent):
    """Proxy of C++ SoVRMLAnchor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLAnchor_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLAnchor_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLAnchor_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLAnchor"""
        this = _coin.new_SoVRMLAnchor()
        try: self.this.append(this)
        except: self.this = this
    url = _swig_property(_coin.SoVRMLAnchor_url_get, _coin.SoVRMLAnchor_url_set)
    description = _swig_property(_coin.SoVRMLAnchor_description_get, _coin.SoVRMLAnchor_description_set)
    parameter = _swig_property(_coin.SoVRMLAnchor_parameter_get, _coin.SoVRMLAnchor_parameter_set)
    bboxCenter = _swig_property(_coin.SoVRMLAnchor_bboxCenter_get, _coin.SoVRMLAnchor_bboxCenter_set)
    bboxSize = _swig_property(_coin.SoVRMLAnchor_bboxSize_get, _coin.SoVRMLAnchor_bboxSize_set)
    def setFetchURLCallBack(*args):
        """setFetchURLCallBack(SoVRMLAnchorCB arg0, void closure)"""
        return _coin.SoVRMLAnchor_setFetchURLCallBack(*args)

    setFetchURLCallBack = staticmethod(setFetchURLCallBack)
    def handleEvent(self, *args):
        """handleEvent(self, SoHandleEventAction action)"""
        return _coin.SoVRMLAnchor_handleEvent(self, *args)

SoVRMLAnchor_swigregister = _coin.SoVRMLAnchor_swigregister
SoVRMLAnchor_swigregister(SoVRMLAnchor)

def SoVRMLAnchor_getClassTypeId():
  """SoVRMLAnchor_getClassTypeId() -> SoType"""
  return _coin.SoVRMLAnchor_getClassTypeId()

def SoVRMLAnchor_initClass():
  """SoVRMLAnchor_initClass()"""
  return _coin.SoVRMLAnchor_initClass()

def SoVRMLAnchor_setFetchURLCallBack(*args):
  """SoVRMLAnchor_setFetchURLCallBack(SoVRMLAnchorCB arg0, void closure)"""
  return _coin.SoVRMLAnchor_setFetchURLCallBack(*args)

class SoVRMLAppearance(SoNode):
    """Proxy of C++ SoVRMLAppearance class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLAppearance_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLAppearance_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLAppearance_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLAppearance"""
        this = _coin.new_SoVRMLAppearance()
        try: self.this.append(this)
        except: self.this = this
    material = _swig_property(_coin.SoVRMLAppearance_material_get, _coin.SoVRMLAppearance_material_set)
    texture = _swig_property(_coin.SoVRMLAppearance_texture_get, _coin.SoVRMLAppearance_texture_set)
    textureTransform = _swig_property(_coin.SoVRMLAppearance_textureTransform_get, _coin.SoVRMLAppearance_textureTransform_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoVRMLAppearance_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoVRMLAppearance_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLAppearance_GLRender(self, *args)

    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoVRMLAppearance_search(self, *args)

    def getChildren(self):
        """getChildren(self) -> SoChildList"""
        return _coin.SoVRMLAppearance_getChildren(self)

    def notify(self, *args):
        """notify(self, SoNotList list)"""
        return _coin.SoVRMLAppearance_notify(self, *args)

    def copyContents(self, *args):
        """copyContents(self, SoFieldContainer srcFrom, SbBool copyConn)"""
        return _coin.SoVRMLAppearance_copyContents(self, *args)

SoVRMLAppearance_swigregister = _coin.SoVRMLAppearance_swigregister
SoVRMLAppearance_swigregister(SoVRMLAppearance)

def SoVRMLAppearance_getClassTypeId():
  """SoVRMLAppearance_getClassTypeId() -> SoType"""
  return _coin.SoVRMLAppearance_getClassTypeId()

def SoVRMLAppearance_initClass():
  """SoVRMLAppearance_initClass()"""
  return _coin.SoVRMLAppearance_initClass()

class SoVRMLAudioClip(SoNode):
    """Proxy of C++ SoVRMLAudioClip class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLAudioClip_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLAudioClip_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLAudioClip_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLAudioClip"""
        this = _coin.new_SoVRMLAudioClip()
        try: self.this.append(this)
        except: self.this = this
    description = _swig_property(_coin.SoVRMLAudioClip_description_get, _coin.SoVRMLAudioClip_description_set)
    loop = _swig_property(_coin.SoVRMLAudioClip_loop_get, _coin.SoVRMLAudioClip_loop_set)
    pitch = _swig_property(_coin.SoVRMLAudioClip_pitch_get, _coin.SoVRMLAudioClip_pitch_set)
    startTime = _swig_property(_coin.SoVRMLAudioClip_startTime_get, _coin.SoVRMLAudioClip_startTime_set)
    stopTime = _swig_property(_coin.SoVRMLAudioClip_stopTime_get, _coin.SoVRMLAudioClip_stopTime_set)
    url = _swig_property(_coin.SoVRMLAudioClip_url_get, _coin.SoVRMLAudioClip_url_set)
    def setSubdirectories(*args):
        """setSubdirectories(SbList<(SbString)> subdirectories)"""
        return _coin.SoVRMLAudioClip_setSubdirectories(*args)

    setSubdirectories = staticmethod(setSubdirectories)
    def getSubdirectories():
        """getSubdirectories() -> SbStringList"""
        return _coin.SoVRMLAudioClip_getSubdirectories()

    getSubdirectories = staticmethod(getSubdirectories)
    def setDefaultPauseBetweenTracks(*args):
        """setDefaultPauseBetweenTracks(SbTime pause)"""
        return _coin.SoVRMLAudioClip_setDefaultPauseBetweenTracks(*args)

    setDefaultPauseBetweenTracks = staticmethod(setDefaultPauseBetweenTracks)
    def getDefaultPauseBetweenTracks():
        """getDefaultPauseBetweenTracks() -> SbTime"""
        return _coin.SoVRMLAudioClip_getDefaultPauseBetweenTracks()

    getDefaultPauseBetweenTracks = staticmethod(getDefaultPauseBetweenTracks)
    def setDefaultIntroPause(*args):
        """setDefaultIntroPause(SbTime pause)"""
        return _coin.SoVRMLAudioClip_setDefaultIntroPause(*args)

    setDefaultIntroPause = staticmethod(setDefaultIntroPause)
    def getDefaultIntroPause():
        """getDefaultIntroPause() -> SbTime"""
        return _coin.SoVRMLAudioClip_getDefaultIntroPause()

    getDefaultIntroPause = staticmethod(getDefaultIntroPause)
    def setDefaultSampleRate(*args):
        """setDefaultSampleRate(int samplerate)"""
        return _coin.SoVRMLAudioClip_setDefaultSampleRate(*args)

    setDefaultSampleRate = staticmethod(setDefaultSampleRate)
    def getDefaultSampleRate():
        """getDefaultSampleRate() -> int"""
        return _coin.SoVRMLAudioClip_getDefaultSampleRate()

    getDefaultSampleRate = staticmethod(getDefaultSampleRate)
    def setDefaultTimerInterval(*args):
        """setDefaultTimerInterval(SbTime interval)"""
        return _coin.SoVRMLAudioClip_setDefaultTimerInterval(*args)

    setDefaultTimerInterval = staticmethod(setDefaultTimerInterval)
    def getDefaultTimerInterval():
        """getDefaultTimerInterval() -> SbTime"""
        return _coin.SoVRMLAudioClip_getDefaultTimerInterval()

    getDefaultTimerInterval = staticmethod(getDefaultTimerInterval)
    def getSampleRate(self):
        """getSampleRate(self) -> int"""
        return _coin.SoVRMLAudioClip_getSampleRate(self)

    def open(self, *args):
        """open(self, SbStringList url) -> void"""
        return _coin.SoVRMLAudioClip_open(self, *args)

    def read(self, *args):
        """read(self, void datasource, void buffer, int numframes, int channels) -> size_t"""
        return _coin.SoVRMLAudioClip_read(self, *args)

    def seek(self, *args):
        """seek(self, void datasource, long offset, int whence) -> int"""
        return _coin.SoVRMLAudioClip_seek(self, *args)

    def tell(self, *args):
        """tell(self, void datasource) -> long"""
        return _coin.SoVRMLAudioClip_tell(self, *args)

    def close(self, *args):
        """close(self, void datasource) -> int"""
        return _coin.SoVRMLAudioClip_close(self, *args)

    def setCallbacks(self, *args):
        """
        setCallbacks(self, open_func opencb, read_func readcb, seek_func seekcb, 
            tell_func tellcb, close_func closecb, void userdataptr)
        """
        return _coin.SoVRMLAudioClip_setCallbacks(self, *args)

SoVRMLAudioClip_swigregister = _coin.SoVRMLAudioClip_swigregister
SoVRMLAudioClip_swigregister(SoVRMLAudioClip)

def SoVRMLAudioClip_getClassTypeId():
  """SoVRMLAudioClip_getClassTypeId() -> SoType"""
  return _coin.SoVRMLAudioClip_getClassTypeId()

def SoVRMLAudioClip_initClass():
  """SoVRMLAudioClip_initClass()"""
  return _coin.SoVRMLAudioClip_initClass()

def SoVRMLAudioClip_setSubdirectories(*args):
  """SoVRMLAudioClip_setSubdirectories(SbList<(SbString)> subdirectories)"""
  return _coin.SoVRMLAudioClip_setSubdirectories(*args)

def SoVRMLAudioClip_getSubdirectories():
  """SoVRMLAudioClip_getSubdirectories() -> SbStringList"""
  return _coin.SoVRMLAudioClip_getSubdirectories()

def SoVRMLAudioClip_setDefaultPauseBetweenTracks(*args):
  """SoVRMLAudioClip_setDefaultPauseBetweenTracks(SbTime pause)"""
  return _coin.SoVRMLAudioClip_setDefaultPauseBetweenTracks(*args)

def SoVRMLAudioClip_getDefaultPauseBetweenTracks():
  """SoVRMLAudioClip_getDefaultPauseBetweenTracks() -> SbTime"""
  return _coin.SoVRMLAudioClip_getDefaultPauseBetweenTracks()

def SoVRMLAudioClip_setDefaultIntroPause(*args):
  """SoVRMLAudioClip_setDefaultIntroPause(SbTime pause)"""
  return _coin.SoVRMLAudioClip_setDefaultIntroPause(*args)

def SoVRMLAudioClip_getDefaultIntroPause():
  """SoVRMLAudioClip_getDefaultIntroPause() -> SbTime"""
  return _coin.SoVRMLAudioClip_getDefaultIntroPause()

def SoVRMLAudioClip_setDefaultSampleRate(*args):
  """SoVRMLAudioClip_setDefaultSampleRate(int samplerate)"""
  return _coin.SoVRMLAudioClip_setDefaultSampleRate(*args)

def SoVRMLAudioClip_getDefaultSampleRate():
  """SoVRMLAudioClip_getDefaultSampleRate() -> int"""
  return _coin.SoVRMLAudioClip_getDefaultSampleRate()

def SoVRMLAudioClip_setDefaultTimerInterval(*args):
  """SoVRMLAudioClip_setDefaultTimerInterval(SbTime interval)"""
  return _coin.SoVRMLAudioClip_setDefaultTimerInterval(*args)

def SoVRMLAudioClip_getDefaultTimerInterval():
  """SoVRMLAudioClip_getDefaultTimerInterval() -> SbTime"""
  return _coin.SoVRMLAudioClip_getDefaultTimerInterval()

class SoVRMLBackground(SoNode):
    """Proxy of C++ SoVRMLBackground class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLBackground_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLBackground_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLBackground_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLBackground"""
        this = _coin.new_SoVRMLBackground()
        try: self.this.append(this)
        except: self.this = this
    groundColor = _swig_property(_coin.SoVRMLBackground_groundColor_get, _coin.SoVRMLBackground_groundColor_set)
    groundAngle = _swig_property(_coin.SoVRMLBackground_groundAngle_get, _coin.SoVRMLBackground_groundAngle_set)
    skyColor = _swig_property(_coin.SoVRMLBackground_skyColor_get, _coin.SoVRMLBackground_skyColor_set)
    skyAngle = _swig_property(_coin.SoVRMLBackground_skyAngle_get, _coin.SoVRMLBackground_skyAngle_set)
    backUrl = _swig_property(_coin.SoVRMLBackground_backUrl_get, _coin.SoVRMLBackground_backUrl_set)
    bottomUrl = _swig_property(_coin.SoVRMLBackground_bottomUrl_get, _coin.SoVRMLBackground_bottomUrl_set)
    frontUrl = _swig_property(_coin.SoVRMLBackground_frontUrl_get, _coin.SoVRMLBackground_frontUrl_set)
    leftUrl = _swig_property(_coin.SoVRMLBackground_leftUrl_get, _coin.SoVRMLBackground_leftUrl_set)
    rightUrl = _swig_property(_coin.SoVRMLBackground_rightUrl_get, _coin.SoVRMLBackground_rightUrl_set)
    topUrl = _swig_property(_coin.SoVRMLBackground_topUrl_get, _coin.SoVRMLBackground_topUrl_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLBackground_GLRender(self, *args)

SoVRMLBackground_swigregister = _coin.SoVRMLBackground_swigregister
SoVRMLBackground_swigregister(SoVRMLBackground)

def SoVRMLBackground_getClassTypeId():
  """SoVRMLBackground_getClassTypeId() -> SoType"""
  return _coin.SoVRMLBackground_getClassTypeId()

def SoVRMLBackground_initClass():
  """SoVRMLBackground_initClass()"""
  return _coin.SoVRMLBackground_initClass()

class SoVRMLBillboard(SoVRMLParent):
    """Proxy of C++ SoVRMLBillboard class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLBillboard_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLBillboard_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLBillboard_initClass()

    initClass = staticmethod(initClass)
    def __init__(self, *args): 
        """
        __init__(self) -> SoVRMLBillboard
        __init__(self, int numchildren) -> SoVRMLBillboard
        """
        this = _coin.new_SoVRMLBillboard(*args)
        try: self.this.append(this)
        except: self.this = this
    axisOfRotation = _swig_property(_coin.SoVRMLBillboard_axisOfRotation_get, _coin.SoVRMLBillboard_axisOfRotation_set)
    bboxCenter = _swig_property(_coin.SoVRMLBillboard_bboxCenter_get, _coin.SoVRMLBillboard_bboxCenter_set)
    bboxSize = _swig_property(_coin.SoVRMLBillboard_bboxSize_get, _coin.SoVRMLBillboard_bboxSize_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoVRMLBillboard_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoVRMLBillboard_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLBillboard_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLBillboard_getBoundingBox(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoVRMLBillboard_getMatrix(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoVRMLBillboard_pick(self, *args)

    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoVRMLBillboard_search(self, *args)

    def GLRenderBelowPath(self, *args):
        """GLRenderBelowPath(self, SoGLRenderAction action)"""
        return _coin.SoVRMLBillboard_GLRenderBelowPath(self, *args)

    def GLRenderInPath(self, *args):
        """GLRenderInPath(self, SoGLRenderAction action)"""
        return _coin.SoVRMLBillboard_GLRenderInPath(self, *args)

    def GLRenderOffPath(self, *args):
        """GLRenderOffPath(self, SoGLRenderAction action)"""
        return _coin.SoVRMLBillboard_GLRenderOffPath(self, *args)

    def notify(self, *args):
        """notify(self, SoNotList list)"""
        return _coin.SoVRMLBillboard_notify(self, *args)

SoVRMLBillboard_swigregister = _coin.SoVRMLBillboard_swigregister
SoVRMLBillboard_swigregister(SoVRMLBillboard)

def SoVRMLBillboard_getClassTypeId():
  """SoVRMLBillboard_getClassTypeId() -> SoType"""
  return _coin.SoVRMLBillboard_getClassTypeId()

def SoVRMLBillboard_initClass():
  """SoVRMLBillboard_initClass()"""
  return _coin.SoVRMLBillboard_initClass()

class SoVRMLGeometry(SoShape):
    """Proxy of C++ SoVRMLGeometry class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLGeometry_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLGeometry_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLGeometry_initClass()

    initClass = staticmethod(initClass)
    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoVRMLGeometry_search(self, *args)

    def copyContents(self, *args):
        """copyContents(self, SoFieldContainer srcFrom, SbBool copyConn)"""
        return _coin.SoVRMLGeometry_copyContents(self, *args)

SoVRMLGeometry_swigregister = _coin.SoVRMLGeometry_swigregister
SoVRMLGeometry_swigregister(SoVRMLGeometry)

def SoVRMLGeometry_getClassTypeId():
  """SoVRMLGeometry_getClassTypeId() -> SoType"""
  return _coin.SoVRMLGeometry_getClassTypeId()

def SoVRMLGeometry_initClass():
  """SoVRMLGeometry_initClass()"""
  return _coin.SoVRMLGeometry_initClass()

class SoVRMLBox(SoVRMLGeometry):
    """Proxy of C++ SoVRMLBox class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLBox_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLBox_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLBox_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLBox"""
        this = _coin.new_SoVRMLBox()
        try: self.this.append(this)
        except: self.this = this
    size = _swig_property(_coin.SoVRMLBox_size_get, _coin.SoVRMLBox_size_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLBox_GLRender(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoVRMLBox_rayPick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLBox_getPrimitiveCount(self, *args)

SoVRMLBox_swigregister = _coin.SoVRMLBox_swigregister
SoVRMLBox_swigregister(SoVRMLBox)

def SoVRMLBox_getClassTypeId():
  """SoVRMLBox_getClassTypeId() -> SoType"""
  return _coin.SoVRMLBox_getClassTypeId()

def SoVRMLBox_initClass():
  """SoVRMLBox_initClass()"""
  return _coin.SoVRMLBox_initClass()

class SoVRMLGroup(SoVRMLParent):
    """Proxy of C++ SoVRMLGroup class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLGroup_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLGroup_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLGroup_initClass()

    initClass = staticmethod(initClass)
    def __init__(self, *args): 
        """
        __init__(self) -> SoVRMLGroup
        __init__(self, int numChildren) -> SoVRMLGroup
        """
        this = _coin.new_SoVRMLGroup(*args)
        try: self.this.append(this)
        except: self.this = this
    OFF = _coin.SoVRMLGroup_OFF
    ON = _coin.SoVRMLGroup_ON
    AUTO = _coin.SoVRMLGroup_AUTO
    renderCaching = _swig_property(_coin.SoVRMLGroup_renderCaching_get, _coin.SoVRMLGroup_renderCaching_set)
    boundingBoxCaching = _swig_property(_coin.SoVRMLGroup_boundingBoxCaching_get, _coin.SoVRMLGroup_boundingBoxCaching_set)
    renderCulling = _swig_property(_coin.SoVRMLGroup_renderCulling_get, _coin.SoVRMLGroup_renderCulling_set)
    pickCulling = _swig_property(_coin.SoVRMLGroup_pickCulling_get, _coin.SoVRMLGroup_pickCulling_set)
    bboxCenter = _swig_property(_coin.SoVRMLGroup_bboxCenter_get, _coin.SoVRMLGroup_bboxCenter_set)
    bboxSize = _swig_property(_coin.SoVRMLGroup_bboxSize_get, _coin.SoVRMLGroup_bboxSize_set)
    def setNumRenderCaches(*args):
        """setNumRenderCaches(int num)"""
        return _coin.SoVRMLGroup_setNumRenderCaches(*args)

    setNumRenderCaches = staticmethod(setNumRenderCaches)
    def getNumRenderCaches():
        """getNumRenderCaches() -> int"""
        return _coin.SoVRMLGroup_getNumRenderCaches()

    getNumRenderCaches = staticmethod(getNumRenderCaches)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoVRMLGroup_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoVRMLGroup_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLGroup_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLGroup_getBoundingBox(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoVRMLGroup_getMatrix(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoVRMLGroup_rayPick(self, *args)

    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoVRMLGroup_search(self, *args)

    def write(self, *args):
        """write(self, SoWriteAction action)"""
        return _coin.SoVRMLGroup_write(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLGroup_getPrimitiveCount(self, *args)

    def audioRender(self, *args):
        """audioRender(self, SoAudioRenderAction action)"""
        return _coin.SoVRMLGroup_audioRender(self, *args)

    def GLRenderBelowPath(self, *args):
        """GLRenderBelowPath(self, SoGLRenderAction action)"""
        return _coin.SoVRMLGroup_GLRenderBelowPath(self, *args)

    def GLRenderInPath(self, *args):
        """GLRenderInPath(self, SoGLRenderAction action)"""
        return _coin.SoVRMLGroup_GLRenderInPath(self, *args)

    def GLRenderOffPath(self, *args):
        """GLRenderOffPath(self, SoGLRenderAction action)"""
        return _coin.SoVRMLGroup_GLRenderOffPath(self, *args)

    def notify(self, *args):
        """notify(self, SoNotList list)"""
        return _coin.SoVRMLGroup_notify(self, *args)

SoVRMLGroup_swigregister = _coin.SoVRMLGroup_swigregister
SoVRMLGroup_swigregister(SoVRMLGroup)

def SoVRMLGroup_getClassTypeId():
  """SoVRMLGroup_getClassTypeId() -> SoType"""
  return _coin.SoVRMLGroup_getClassTypeId()

def SoVRMLGroup_initClass():
  """SoVRMLGroup_initClass()"""
  return _coin.SoVRMLGroup_initClass()

def SoVRMLGroup_setNumRenderCaches(*args):
  """SoVRMLGroup_setNumRenderCaches(int num)"""
  return _coin.SoVRMLGroup_setNumRenderCaches(*args)

def SoVRMLGroup_getNumRenderCaches():
  """SoVRMLGroup_getNumRenderCaches() -> int"""
  return _coin.SoVRMLGroup_getNumRenderCaches()

class SoVRMLCollision(SoVRMLGroup):
    """Proxy of C++ SoVRMLCollision class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLCollision_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLCollision_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLCollision_initClass()

    initClass = staticmethod(initClass)
    def __init__(self, *args): 
        """
        __init__(self) -> SoVRMLCollision
        __init__(self, int numchildren) -> SoVRMLCollision
        """
        this = _coin.new_SoVRMLCollision(*args)
        try: self.this.append(this)
        except: self.this = this
    collide = _swig_property(_coin.SoVRMLCollision_collide_get, _coin.SoVRMLCollision_collide_set)
    proxy = _swig_property(_coin.SoVRMLCollision_proxy_get, _coin.SoVRMLCollision_proxy_set)
    collideTime = _swig_property(_coin.SoVRMLCollision_collideTime_get, _coin.SoVRMLCollision_collideTime_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLCollision_GLRender(self, *args)

    def notify(self, *args):
        """notify(self, SoNotList list)"""
        return _coin.SoVRMLCollision_notify(self, *args)

SoVRMLCollision_swigregister = _coin.SoVRMLCollision_swigregister
SoVRMLCollision_swigregister(SoVRMLCollision)

def SoVRMLCollision_getClassTypeId():
  """SoVRMLCollision_getClassTypeId() -> SoType"""
  return _coin.SoVRMLCollision_getClassTypeId()

def SoVRMLCollision_initClass():
  """SoVRMLCollision_initClass()"""
  return _coin.SoVRMLCollision_initClass()

class SoVRMLColor(SoNode):
    """Proxy of C++ SoVRMLColor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLColor_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLColor_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLColor_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLColor"""
        this = _coin.new_SoVRMLColor()
        try: self.this.append(this)
        except: self.this = this
    color = _swig_property(_coin.SoVRMLColor_color_get, _coin.SoVRMLColor_color_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoVRMLColor_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLColor_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoVRMLColor_callback(self, *args)

SoVRMLColor_swigregister = _coin.SoVRMLColor_swigregister
SoVRMLColor_swigregister(SoVRMLColor)

def SoVRMLColor_getClassTypeId():
  """SoVRMLColor_getClassTypeId() -> SoType"""
  return _coin.SoVRMLColor_getClassTypeId()

def SoVRMLColor_initClass():
  """SoVRMLColor_initClass()"""
  return _coin.SoVRMLColor_initClass()

class SoVRMLInterpolator(SoNodeEngine):
    """Proxy of C++ SoVRMLInterpolator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLInterpolator_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLInterpolator_getTypeId(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoVRMLInterpolator_getOutputData(self)

    key = _swig_property(_coin.SoVRMLInterpolator_key_get, _coin.SoVRMLInterpolator_key_set)
    set_fraction = _swig_property(_coin.SoVRMLInterpolator_set_fraction_get, _coin.SoVRMLInterpolator_set_fraction_set)
    def initClass():
        """initClass()"""
        return _coin.SoVRMLInterpolator_initClass()

    initClass = staticmethod(initClass)
SoVRMLInterpolator_swigregister = _coin.SoVRMLInterpolator_swigregister
SoVRMLInterpolator_swigregister(SoVRMLInterpolator)

def SoVRMLInterpolator_getClassTypeId():
  """SoVRMLInterpolator_getClassTypeId() -> SoType"""
  return _coin.SoVRMLInterpolator_getClassTypeId()

def SoVRMLInterpolator_initClass():
  """SoVRMLInterpolator_initClass()"""
  return _coin.SoVRMLInterpolator_initClass()

class SoVRMLColorInterpolator(SoVRMLInterpolator):
    """Proxy of C++ SoVRMLColorInterpolator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLColorInterpolator_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLColorInterpolator_getTypeId(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoVRMLColorInterpolator_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoVRMLColorInterpolator_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoVRMLColorInterpolator_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLColorInterpolator"""
        this = _coin.new_SoVRMLColorInterpolator()
        try: self.this.append(this)
        except: self.this = this
    keyValue = _swig_property(_coin.SoVRMLColorInterpolator_keyValue_get, _coin.SoVRMLColorInterpolator_keyValue_set)
    value_changed = _swig_property(_coin.SoVRMLColorInterpolator_value_changed_get, _coin.SoVRMLColorInterpolator_value_changed_set)
SoVRMLColorInterpolator_swigregister = _coin.SoVRMLColorInterpolator_swigregister
SoVRMLColorInterpolator_swigregister(SoVRMLColorInterpolator)

def SoVRMLColorInterpolator_getClassTypeId():
  """SoVRMLColorInterpolator_getClassTypeId() -> SoType"""
  return _coin.SoVRMLColorInterpolator_getClassTypeId()

def SoVRMLColorInterpolator_createInstance():
  """SoVRMLColorInterpolator_createInstance() -> void"""
  return _coin.SoVRMLColorInterpolator_createInstance()

def SoVRMLColorInterpolator_initClass():
  """SoVRMLColorInterpolator_initClass()"""
  return _coin.SoVRMLColorInterpolator_initClass()

class SoVRMLCone(SoVRMLGeometry):
    """Proxy of C++ SoVRMLCone class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLCone_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLCone_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLCone_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLCone"""
        this = _coin.new_SoVRMLCone()
        try: self.this.append(this)
        except: self.this = this
    bottomRadius = _swig_property(_coin.SoVRMLCone_bottomRadius_get, _coin.SoVRMLCone_bottomRadius_set)
    height = _swig_property(_coin.SoVRMLCone_height_get, _coin.SoVRMLCone_height_set)
    side = _swig_property(_coin.SoVRMLCone_side_get, _coin.SoVRMLCone_side_set)
    bottom = _swig_property(_coin.SoVRMLCone_bottom_get, _coin.SoVRMLCone_bottom_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLCone_GLRender(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoVRMLCone_rayPick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLCone_getPrimitiveCount(self, *args)

SoVRMLCone_swigregister = _coin.SoVRMLCone_swigregister
SoVRMLCone_swigregister(SoVRMLCone)

def SoVRMLCone_getClassTypeId():
  """SoVRMLCone_getClassTypeId() -> SoType"""
  return _coin.SoVRMLCone_getClassTypeId()

def SoVRMLCone_initClass():
  """SoVRMLCone_initClass()"""
  return _coin.SoVRMLCone_initClass()

class SoVRMLCoordinate(SoNode):
    """Proxy of C++ SoVRMLCoordinate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLCoordinate_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLCoordinate_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLCoordinate_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLCoordinate"""
        this = _coin.new_SoVRMLCoordinate()
        try: self.this.append(this)
        except: self.this = this
    point = _swig_property(_coin.SoVRMLCoordinate_point_get, _coin.SoVRMLCoordinate_point_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoVRMLCoordinate_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLCoordinate_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLCoordinate_getBoundingBox(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoVRMLCoordinate_callback(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoVRMLCoordinate_pick(self, *args)

SoVRMLCoordinate_swigregister = _coin.SoVRMLCoordinate_swigregister
SoVRMLCoordinate_swigregister(SoVRMLCoordinate)

def SoVRMLCoordinate_getClassTypeId():
  """SoVRMLCoordinate_getClassTypeId() -> SoType"""
  return _coin.SoVRMLCoordinate_getClassTypeId()

def SoVRMLCoordinate_initClass():
  """SoVRMLCoordinate_initClass()"""
  return _coin.SoVRMLCoordinate_initClass()

class SoVRMLCoordinateInterpolator(SoVRMLInterpolator):
    """Proxy of C++ SoVRMLCoordinateInterpolator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLCoordinateInterpolator_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLCoordinateInterpolator_getTypeId(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoVRMLCoordinateInterpolator_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoVRMLCoordinateInterpolator_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoVRMLCoordinateInterpolator_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLCoordinateInterpolator"""
        this = _coin.new_SoVRMLCoordinateInterpolator()
        try: self.this.append(this)
        except: self.this = this
    keyValue = _swig_property(_coin.SoVRMLCoordinateInterpolator_keyValue_get, _coin.SoVRMLCoordinateInterpolator_keyValue_set)
    value_changed = _swig_property(_coin.SoVRMLCoordinateInterpolator_value_changed_get, _coin.SoVRMLCoordinateInterpolator_value_changed_set)
SoVRMLCoordinateInterpolator_swigregister = _coin.SoVRMLCoordinateInterpolator_swigregister
SoVRMLCoordinateInterpolator_swigregister(SoVRMLCoordinateInterpolator)

def SoVRMLCoordinateInterpolator_getClassTypeId():
  """SoVRMLCoordinateInterpolator_getClassTypeId() -> SoType"""
  return _coin.SoVRMLCoordinateInterpolator_getClassTypeId()

def SoVRMLCoordinateInterpolator_createInstance():
  """SoVRMLCoordinateInterpolator_createInstance() -> void"""
  return _coin.SoVRMLCoordinateInterpolator_createInstance()

def SoVRMLCoordinateInterpolator_initClass():
  """SoVRMLCoordinateInterpolator_initClass()"""
  return _coin.SoVRMLCoordinateInterpolator_initClass()

class SoVRMLCylinder(SoVRMLGeometry):
    """Proxy of C++ SoVRMLCylinder class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLCylinder_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLCylinder_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLCylinder_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLCylinder"""
        this = _coin.new_SoVRMLCylinder()
        try: self.this.append(this)
        except: self.this = this
    radius = _swig_property(_coin.SoVRMLCylinder_radius_get, _coin.SoVRMLCylinder_radius_set)
    height = _swig_property(_coin.SoVRMLCylinder_height_get, _coin.SoVRMLCylinder_height_set)
    side = _swig_property(_coin.SoVRMLCylinder_side_get, _coin.SoVRMLCylinder_side_set)
    top = _swig_property(_coin.SoVRMLCylinder_top_get, _coin.SoVRMLCylinder_top_set)
    bottom = _swig_property(_coin.SoVRMLCylinder_bottom_get, _coin.SoVRMLCylinder_bottom_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLCylinder_GLRender(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoVRMLCylinder_rayPick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLCylinder_getPrimitiveCount(self, *args)

SoVRMLCylinder_swigregister = _coin.SoVRMLCylinder_swigregister
SoVRMLCylinder_swigregister(SoVRMLCylinder)

def SoVRMLCylinder_getClassTypeId():
  """SoVRMLCylinder_getClassTypeId() -> SoType"""
  return _coin.SoVRMLCylinder_getClassTypeId()

def SoVRMLCylinder_initClass():
  """SoVRMLCylinder_initClass()"""
  return _coin.SoVRMLCylinder_initClass()

class SoVRMLSensor(SoNode):
    """Proxy of C++ SoVRMLSensor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLSensor_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLSensor_getTypeId(self)

    isActive = _swig_property(_coin.SoVRMLSensor_isActive_get, _coin.SoVRMLSensor_isActive_set)
    enabled = _swig_property(_coin.SoVRMLSensor_enabled_get, _coin.SoVRMLSensor_enabled_set)
    def initClass():
        """initClass()"""
        return _coin.SoVRMLSensor_initClass()

    initClass = staticmethod(initClass)
SoVRMLSensor_swigregister = _coin.SoVRMLSensor_swigregister
SoVRMLSensor_swigregister(SoVRMLSensor)

def SoVRMLSensor_getClassTypeId():
  """SoVRMLSensor_getClassTypeId() -> SoType"""
  return _coin.SoVRMLSensor_getClassTypeId()

def SoVRMLSensor_initClass():
  """SoVRMLSensor_initClass()"""
  return _coin.SoVRMLSensor_initClass()

class SoVRMLDragSensor(SoVRMLSensor):
    """Proxy of C++ SoVRMLDragSensor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLDragSensor_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLDragSensor_getTypeId(self)

    trackPoint_changed = _swig_property(_coin.SoVRMLDragSensor_trackPoint_changed_get, _coin.SoVRMLDragSensor_trackPoint_changed_set)
    autoOffset = _swig_property(_coin.SoVRMLDragSensor_autoOffset_get, _coin.SoVRMLDragSensor_autoOffset_set)
    def handleEvent(self, *args):
        """handleEvent(self, SoHandleEventAction action)"""
        return _coin.SoVRMLDragSensor_handleEvent(self, *args)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLDragSensor_initClass()

    initClass = staticmethod(initClass)
SoVRMLDragSensor_swigregister = _coin.SoVRMLDragSensor_swigregister
SoVRMLDragSensor_swigregister(SoVRMLDragSensor)

def SoVRMLDragSensor_getClassTypeId():
  """SoVRMLDragSensor_getClassTypeId() -> SoType"""
  return _coin.SoVRMLDragSensor_getClassTypeId()

def SoVRMLDragSensor_initClass():
  """SoVRMLDragSensor_initClass()"""
  return _coin.SoVRMLDragSensor_initClass()

class SoVRMLCylinderSensor(SoVRMLDragSensor):
    """Proxy of C++ SoVRMLCylinderSensor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLCylinderSensor_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLCylinderSensor_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLCylinderSensor_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLCylinderSensor"""
        this = _coin.new_SoVRMLCylinderSensor()
        try: self.this.append(this)
        except: self.this = this
    diskAngle = _swig_property(_coin.SoVRMLCylinderSensor_diskAngle_get, _coin.SoVRMLCylinderSensor_diskAngle_set)
    maxAngle = _swig_property(_coin.SoVRMLCylinderSensor_maxAngle_get, _coin.SoVRMLCylinderSensor_maxAngle_set)
    minAngle = _swig_property(_coin.SoVRMLCylinderSensor_minAngle_get, _coin.SoVRMLCylinderSensor_minAngle_set)
    offset = _swig_property(_coin.SoVRMLCylinderSensor_offset_get, _coin.SoVRMLCylinderSensor_offset_set)
    rotation_changed = _swig_property(_coin.SoVRMLCylinderSensor_rotation_changed_get, _coin.SoVRMLCylinderSensor_rotation_changed_set)
SoVRMLCylinderSensor_swigregister = _coin.SoVRMLCylinderSensor_swigregister
SoVRMLCylinderSensor_swigregister(SoVRMLCylinderSensor)

def SoVRMLCylinderSensor_getClassTypeId():
  """SoVRMLCylinderSensor_getClassTypeId() -> SoType"""
  return _coin.SoVRMLCylinderSensor_getClassTypeId()

def SoVRMLCylinderSensor_initClass():
  """SoVRMLCylinderSensor_initClass()"""
  return _coin.SoVRMLCylinderSensor_initClass()

class SoVRMLLight(SoNode):
    """Proxy of C++ SoVRMLLight class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLLight_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLLight_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLLight_initClass()

    initClass = staticmethod(initClass)
    on = _swig_property(_coin.SoVRMLLight_on_get, _coin.SoVRMLLight_on_set)
    intensity = _swig_property(_coin.SoVRMLLight_intensity_get, _coin.SoVRMLLight_intensity_set)
    color = _swig_property(_coin.SoVRMLLight_color_get, _coin.SoVRMLLight_color_set)
    ambientIntensity = _swig_property(_coin.SoVRMLLight_ambientIntensity_get, _coin.SoVRMLLight_ambientIntensity_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLLight_GLRender(self, *args)

SoVRMLLight_swigregister = _coin.SoVRMLLight_swigregister
SoVRMLLight_swigregister(SoVRMLLight)

def SoVRMLLight_getClassTypeId():
  """SoVRMLLight_getClassTypeId() -> SoType"""
  return _coin.SoVRMLLight_getClassTypeId()

def SoVRMLLight_initClass():
  """SoVRMLLight_initClass()"""
  return _coin.SoVRMLLight_initClass()

class SoVRMLDirectionalLight(SoVRMLLight):
    """Proxy of C++ SoVRMLDirectionalLight class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLDirectionalLight_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLDirectionalLight_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLDirectionalLight_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLDirectionalLight"""
        this = _coin.new_SoVRMLDirectionalLight()
        try: self.this.append(this)
        except: self.this = this
    direction = _swig_property(_coin.SoVRMLDirectionalLight_direction_get, _coin.SoVRMLDirectionalLight_direction_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLDirectionalLight_GLRender(self, *args)

SoVRMLDirectionalLight_swigregister = _coin.SoVRMLDirectionalLight_swigregister
SoVRMLDirectionalLight_swigregister(SoVRMLDirectionalLight)

def SoVRMLDirectionalLight_getClassTypeId():
  """SoVRMLDirectionalLight_getClassTypeId() -> SoType"""
  return _coin.SoVRMLDirectionalLight_getClassTypeId()

def SoVRMLDirectionalLight_initClass():
  """SoVRMLDirectionalLight_initClass()"""
  return _coin.SoVRMLDirectionalLight_initClass()

class SoVRMLElevationGrid(SoVRMLGeometry):
    """Proxy of C++ SoVRMLElevationGrid class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLElevationGrid_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLElevationGrid_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLElevationGrid_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLElevationGrid"""
        this = _coin.new_SoVRMLElevationGrid()
        try: self.this.append(this)
        except: self.this = this
    ccw = _swig_property(_coin.SoVRMLElevationGrid_ccw_get, _coin.SoVRMLElevationGrid_ccw_set)
    solid = _swig_property(_coin.SoVRMLElevationGrid_solid_get, _coin.SoVRMLElevationGrid_solid_set)
    creaseAngle = _swig_property(_coin.SoVRMLElevationGrid_creaseAngle_get, _coin.SoVRMLElevationGrid_creaseAngle_set)
    zDimension = _swig_property(_coin.SoVRMLElevationGrid_zDimension_get, _coin.SoVRMLElevationGrid_zDimension_set)
    xDimension = _swig_property(_coin.SoVRMLElevationGrid_xDimension_get, _coin.SoVRMLElevationGrid_xDimension_set)
    zSpacing = _swig_property(_coin.SoVRMLElevationGrid_zSpacing_get, _coin.SoVRMLElevationGrid_zSpacing_set)
    xSpacing = _swig_property(_coin.SoVRMLElevationGrid_xSpacing_get, _coin.SoVRMLElevationGrid_xSpacing_set)
    height = _swig_property(_coin.SoVRMLElevationGrid_height_get, _coin.SoVRMLElevationGrid_height_set)
    texCoord = _swig_property(_coin.SoVRMLElevationGrid_texCoord_get, _coin.SoVRMLElevationGrid_texCoord_set)
    normal = _swig_property(_coin.SoVRMLElevationGrid_normal_get, _coin.SoVRMLElevationGrid_normal_set)
    color = _swig_property(_coin.SoVRMLElevationGrid_color_get, _coin.SoVRMLElevationGrid_color_set)
    colorPerVertex = _swig_property(_coin.SoVRMLElevationGrid_colorPerVertex_get, _coin.SoVRMLElevationGrid_colorPerVertex_set)
    normalPerVertex = _swig_property(_coin.SoVRMLElevationGrid_normalPerVertex_get, _coin.SoVRMLElevationGrid_normalPerVertex_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLElevationGrid_GLRender(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoVRMLElevationGrid_rayPick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLElevationGrid_getPrimitiveCount(self, *args)

SoVRMLElevationGrid_swigregister = _coin.SoVRMLElevationGrid_swigregister
SoVRMLElevationGrid_swigregister(SoVRMLElevationGrid)

def SoVRMLElevationGrid_getClassTypeId():
  """SoVRMLElevationGrid_getClassTypeId() -> SoType"""
  return _coin.SoVRMLElevationGrid_getClassTypeId()

def SoVRMLElevationGrid_initClass():
  """SoVRMLElevationGrid_initClass()"""
  return _coin.SoVRMLElevationGrid_initClass()

class SoVRMLExtrusion(SoVRMLGeometry):
    """Proxy of C++ SoVRMLExtrusion class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLExtrusion_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLExtrusion_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLExtrusion_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLExtrusion"""
        this = _coin.new_SoVRMLExtrusion()
        try: self.this.append(this)
        except: self.this = this
    beginCap = _swig_property(_coin.SoVRMLExtrusion_beginCap_get, _coin.SoVRMLExtrusion_beginCap_set)
    ccw = _swig_property(_coin.SoVRMLExtrusion_ccw_get, _coin.SoVRMLExtrusion_ccw_set)
    convex = _swig_property(_coin.SoVRMLExtrusion_convex_get, _coin.SoVRMLExtrusion_convex_set)
    creaseAngle = _swig_property(_coin.SoVRMLExtrusion_creaseAngle_get, _coin.SoVRMLExtrusion_creaseAngle_set)
    crossSection = _swig_property(_coin.SoVRMLExtrusion_crossSection_get, _coin.SoVRMLExtrusion_crossSection_set)
    endCap = _swig_property(_coin.SoVRMLExtrusion_endCap_get, _coin.SoVRMLExtrusion_endCap_set)
    orientation = _swig_property(_coin.SoVRMLExtrusion_orientation_get, _coin.SoVRMLExtrusion_orientation_set)
    scale = _swig_property(_coin.SoVRMLExtrusion_scale_get, _coin.SoVRMLExtrusion_scale_set)
    solid = _swig_property(_coin.SoVRMLExtrusion_solid_get, _coin.SoVRMLExtrusion_solid_set)
    spine = _swig_property(_coin.SoVRMLExtrusion_spine_get, _coin.SoVRMLExtrusion_spine_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLExtrusion_GLRender(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLExtrusion_getPrimitiveCount(self, *args)

    def computeBBox(self, *args):
        """computeBBox(self, SoAction action, SbBox3f bbox, SbVec3f center)"""
        return _coin.SoVRMLExtrusion_computeBBox(self, *args)

SoVRMLExtrusion_swigregister = _coin.SoVRMLExtrusion_swigregister
SoVRMLExtrusion_swigregister(SoVRMLExtrusion)

def SoVRMLExtrusion_getClassTypeId():
  """SoVRMLExtrusion_getClassTypeId() -> SoType"""
  return _coin.SoVRMLExtrusion_getClassTypeId()

def SoVRMLExtrusion_initClass():
  """SoVRMLExtrusion_initClass()"""
  return _coin.SoVRMLExtrusion_initClass()

class SoVRMLFog(SoNode):
    """Proxy of C++ SoVRMLFog class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLFog_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLFog_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLFog_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLFog"""
        this = _coin.new_SoVRMLFog()
        try: self.this.append(this)
        except: self.this = this
    fogType = _swig_property(_coin.SoVRMLFog_fogType_get, _coin.SoVRMLFog_fogType_set)
    visibilityRange = _swig_property(_coin.SoVRMLFog_visibilityRange_get, _coin.SoVRMLFog_visibilityRange_set)
    color = _swig_property(_coin.SoVRMLFog_color_get, _coin.SoVRMLFog_color_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLFog_GLRender(self, *args)

SoVRMLFog_swigregister = _coin.SoVRMLFog_swigregister
SoVRMLFog_swigregister(SoVRMLFog)

def SoVRMLFog_getClassTypeId():
  """SoVRMLFog_getClassTypeId() -> SoType"""
  return _coin.SoVRMLFog_getClassTypeId()

def SoVRMLFog_initClass():
  """SoVRMLFog_initClass()"""
  return _coin.SoVRMLFog_initClass()

class SoVRMLFontStyle(SoNode):
    """Proxy of C++ SoVRMLFontStyle class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLFontStyle_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLFontStyle_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLFontStyle_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLFontStyle"""
        this = _coin.new_SoVRMLFontStyle()
        try: self.this.append(this)
        except: self.this = this
    SERIF = _coin.SoVRMLFontStyle_SERIF
    SANS = _coin.SoVRMLFontStyle_SANS
    TYPEWRITER = _coin.SoVRMLFontStyle_TYPEWRITER
    PLAIN = _coin.SoVRMLFontStyle_PLAIN
    BOLD = _coin.SoVRMLFontStyle_BOLD
    ITALIC = _coin.SoVRMLFontStyle_ITALIC
    BOLDITALIC = _coin.SoVRMLFontStyle_BOLDITALIC
    size = _swig_property(_coin.SoVRMLFontStyle_size_get, _coin.SoVRMLFontStyle_size_set)
    family = _swig_property(_coin.SoVRMLFontStyle_family_get, _coin.SoVRMLFontStyle_family_set)
    style = _swig_property(_coin.SoVRMLFontStyle_style_get, _coin.SoVRMLFontStyle_style_set)
    horizontal = _swig_property(_coin.SoVRMLFontStyle_horizontal_get, _coin.SoVRMLFontStyle_horizontal_set)
    leftToRight = _swig_property(_coin.SoVRMLFontStyle_leftToRight_get, _coin.SoVRMLFontStyle_leftToRight_set)
    topToBottom = _swig_property(_coin.SoVRMLFontStyle_topToBottom_get, _coin.SoVRMLFontStyle_topToBottom_set)
    language = _swig_property(_coin.SoVRMLFontStyle_language_get, _coin.SoVRMLFontStyle_language_set)
    justify = _swig_property(_coin.SoVRMLFontStyle_justify_get, _coin.SoVRMLFontStyle_justify_set)
    spacing = _swig_property(_coin.SoVRMLFontStyle_spacing_get, _coin.SoVRMLFontStyle_spacing_set)
    def getFontName(self):
        """getFontName(self) -> SbString"""
        return _coin.SoVRMLFontStyle_getFontName(self)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoVRMLFontStyle_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoVRMLFontStyle_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLFontStyle_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLFontStyle_getBoundingBox(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoVRMLFontStyle_pick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLFontStyle_getPrimitiveCount(self, *args)

SoVRMLFontStyle_swigregister = _coin.SoVRMLFontStyle_swigregister
SoVRMLFontStyle_swigregister(SoVRMLFontStyle)

def SoVRMLFontStyle_getClassTypeId():
  """SoVRMLFontStyle_getClassTypeId() -> SoType"""
  return _coin.SoVRMLFontStyle_getClassTypeId()

def SoVRMLFontStyle_initClass():
  """SoVRMLFontStyle_initClass()"""
  return _coin.SoVRMLFontStyle_initClass()


def so_vrml_init():
  """so_vrml_init()"""
  return _coin.so_vrml_init()
class SoVRMLTexture(SoNode):
    """Proxy of C++ SoVRMLTexture class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLTexture_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLTexture_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLTexture_initClass()

    initClass = staticmethod(initClass)
    repeatS = _swig_property(_coin.SoVRMLTexture_repeatS_get, _coin.SoVRMLTexture_repeatS_set)
    repeatT = _swig_property(_coin.SoVRMLTexture_repeatT_get, _coin.SoVRMLTexture_repeatT_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLTexture_GLRender(self, *args)

SoVRMLTexture_swigregister = _coin.SoVRMLTexture_swigregister
SoVRMLTexture_swigregister(SoVRMLTexture)

def SoVRMLTexture_getClassTypeId():
  """SoVRMLTexture_getClassTypeId() -> SoType"""
  return _coin.SoVRMLTexture_getClassTypeId()

def SoVRMLTexture_initClass():
  """SoVRMLTexture_initClass()"""
  return _coin.SoVRMLTexture_initClass()

class SoVRMLImageTexture(SoVRMLTexture):
    """Proxy of C++ SoVRMLImageTexture class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLImageTexture_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLImageTexture_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLImageTexture_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLImageTexture"""
        this = _coin.new_SoVRMLImageTexture()
        try: self.this.append(this)
        except: self.this = this
    url = _swig_property(_coin.SoVRMLImageTexture_url_get, _coin.SoVRMLImageTexture_url_set)
    def setDelayFetchURL(*args):
        """setDelayFetchURL(SbBool onoff)"""
        return _coin.SoVRMLImageTexture_setDelayFetchURL(*args)

    setDelayFetchURL = staticmethod(setDelayFetchURL)
    def setPrequalifyFileCallBack(*args):
        """setPrequalifyFileCallBack(VRMLPrequalifyFileCallback cb, void closure)"""
        return _coin.SoVRMLImageTexture_setPrequalifyFileCallBack(*args)

    setPrequalifyFileCallBack = staticmethod(setPrequalifyFileCallBack)
    def allowPrequalifyFile(self, *args):
        """allowPrequalifyFile(self, SbBool enable)"""
        return _coin.SoVRMLImageTexture_allowPrequalifyFile(self, *args)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoVRMLImageTexture_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLImageTexture_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoVRMLImageTexture_callback(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoVRMLImageTexture_rayPick(self, *args)

    def setImage(self, *args):
        """setImage(self, SbImage image)"""
        return _coin.SoVRMLImageTexture_setImage(self, *args)

    def getImage(self):
        """getImage(self) -> SbImage"""
        return _coin.SoVRMLImageTexture_getImage(self)

    def setImageDataMaxAge(*args):
        """setImageDataMaxAge(uint32_t maxage)"""
        return _coin.SoVRMLImageTexture_setImageDataMaxAge(*args)

    setImageDataMaxAge = staticmethod(setImageDataMaxAge)
SoVRMLImageTexture_swigregister = _coin.SoVRMLImageTexture_swigregister
SoVRMLImageTexture_swigregister(SoVRMLImageTexture)

def SoVRMLImageTexture_getClassTypeId():
  """SoVRMLImageTexture_getClassTypeId() -> SoType"""
  return _coin.SoVRMLImageTexture_getClassTypeId()

def SoVRMLImageTexture_initClass():
  """SoVRMLImageTexture_initClass()"""
  return _coin.SoVRMLImageTexture_initClass()

def SoVRMLImageTexture_setDelayFetchURL(*args):
  """SoVRMLImageTexture_setDelayFetchURL(SbBool onoff)"""
  return _coin.SoVRMLImageTexture_setDelayFetchURL(*args)

def SoVRMLImageTexture_setPrequalifyFileCallBack(*args):
  """SoVRMLImageTexture_setPrequalifyFileCallBack(VRMLPrequalifyFileCallback cb, void closure)"""
  return _coin.SoVRMLImageTexture_setPrequalifyFileCallBack(*args)

def SoVRMLImageTexture_setImageDataMaxAge(*args):
  """SoVRMLImageTexture_setImageDataMaxAge(uint32_t maxage)"""
  return _coin.SoVRMLImageTexture_setImageDataMaxAge(*args)

class SoVRMLVertexShape(SoVRMLGeometry):
    """Proxy of C++ SoVRMLVertexShape class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLVertexShape_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLVertexShape_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLVertexShape_initClass()

    initClass = staticmethod(initClass)
    coord = _swig_property(_coin.SoVRMLVertexShape_coord_get, _coin.SoVRMLVertexShape_coord_set)
    texCoord = _swig_property(_coin.SoVRMLVertexShape_texCoord_get, _coin.SoVRMLVertexShape_texCoord_set)
    normal = _swig_property(_coin.SoVRMLVertexShape_normal_get, _coin.SoVRMLVertexShape_normal_set)
    color = _swig_property(_coin.SoVRMLVertexShape_color_get, _coin.SoVRMLVertexShape_color_set)
    colorPerVertex = _swig_property(_coin.SoVRMLVertexShape_colorPerVertex_get, _coin.SoVRMLVertexShape_colorPerVertex_set)
    normalPerVertex = _swig_property(_coin.SoVRMLVertexShape_normalPerVertex_get, _coin.SoVRMLVertexShape_normalPerVertex_set)
    OVERALL = _coin.SoVRMLVertexShape_OVERALL
    PER_PART = _coin.SoVRMLVertexShape_PER_PART
    PER_PART_INDEXED = _coin.SoVRMLVertexShape_PER_PART_INDEXED
    PER_FACE = _coin.SoVRMLVertexShape_PER_FACE
    PER_FACE_INDEXED = _coin.SoVRMLVertexShape_PER_FACE_INDEXED
    PER_VERTEX = _coin.SoVRMLVertexShape_PER_VERTEX
    PER_VERTEX_INDEXED = _coin.SoVRMLVertexShape_PER_VERTEX_INDEXED
    def generateDefaultNormals(self, *args):
        """
        generateDefaultNormals(self, SoState s, SoNormalBundle nb) -> SbBool
        generateDefaultNormals(self, SoState s, SoNormalCache nc) -> SbBool
        """
        return _coin.SoVRMLVertexShape_generateDefaultNormals(self, *args)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoVRMLVertexShape_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLVertexShape_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLVertexShape_getBoundingBox(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoVRMLVertexShape_callback(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoVRMLVertexShape_pick(self, *args)

    def notify(self, *args):
        """notify(self, SoNotList list)"""
        return _coin.SoVRMLVertexShape_notify(self, *args)

SoVRMLVertexShape_swigregister = _coin.SoVRMLVertexShape_swigregister
SoVRMLVertexShape_swigregister(SoVRMLVertexShape)

def SoVRMLVertexShape_getClassTypeId():
  """SoVRMLVertexShape_getClassTypeId() -> SoType"""
  return _coin.SoVRMLVertexShape_getClassTypeId()

def SoVRMLVertexShape_initClass():
  """SoVRMLVertexShape_initClass()"""
  return _coin.SoVRMLVertexShape_initClass()

class SoVRMLIndexedShape(SoVRMLVertexShape):
    """Proxy of C++ SoVRMLIndexedShape class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLIndexedShape_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLIndexedShape_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLIndexedShape_initClass()

    initClass = staticmethod(initClass)
    coordIndex = _swig_property(_coin.SoVRMLIndexedShape_coordIndex_get, _coin.SoVRMLIndexedShape_coordIndex_set)
    colorIndex = _swig_property(_coin.SoVRMLIndexedShape_colorIndex_get, _coin.SoVRMLIndexedShape_colorIndex_set)
    normalIndex = _swig_property(_coin.SoVRMLIndexedShape_normalIndex_get, _coin.SoVRMLIndexedShape_normalIndex_set)
    texCoordIndex = _swig_property(_coin.SoVRMLIndexedShape_texCoordIndex_get, _coin.SoVRMLIndexedShape_texCoordIndex_set)
SoVRMLIndexedShape_swigregister = _coin.SoVRMLIndexedShape_swigregister
SoVRMLIndexedShape_swigregister(SoVRMLIndexedShape)

def SoVRMLIndexedShape_getClassTypeId():
  """SoVRMLIndexedShape_getClassTypeId() -> SoType"""
  return _coin.SoVRMLIndexedShape_getClassTypeId()

def SoVRMLIndexedShape_initClass():
  """SoVRMLIndexedShape_initClass()"""
  return _coin.SoVRMLIndexedShape_initClass()

class SoVRMLIndexedFaceSet(SoVRMLIndexedShape):
    """Proxy of C++ SoVRMLIndexedFaceSet class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLIndexedFaceSet_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLIndexedFaceSet_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLIndexedFaceSet_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLIndexedFaceSet"""
        this = _coin.new_SoVRMLIndexedFaceSet()
        try: self.this.append(this)
        except: self.this = this
    ccw = _swig_property(_coin.SoVRMLIndexedFaceSet_ccw_get, _coin.SoVRMLIndexedFaceSet_ccw_set)
    solid = _swig_property(_coin.SoVRMLIndexedFaceSet_solid_get, _coin.SoVRMLIndexedFaceSet_solid_set)
    convex = _swig_property(_coin.SoVRMLIndexedFaceSet_convex_get, _coin.SoVRMLIndexedFaceSet_convex_set)
    creaseAngle = _swig_property(_coin.SoVRMLIndexedFaceSet_creaseAngle_get, _coin.SoVRMLIndexedFaceSet_creaseAngle_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLIndexedFaceSet_GLRender(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLIndexedFaceSet_getPrimitiveCount(self, *args)

    def generateDefaultNormals(self, *args):
        """
        generateDefaultNormals(self, SoState s, SoNormalBundle nb) -> SbBool
        generateDefaultNormals(self, SoState state, SoNormalCache nc) -> SbBool
        """
        return _coin.SoVRMLIndexedFaceSet_generateDefaultNormals(self, *args)

SoVRMLIndexedFaceSet_swigregister = _coin.SoVRMLIndexedFaceSet_swigregister
SoVRMLIndexedFaceSet_swigregister(SoVRMLIndexedFaceSet)

def SoVRMLIndexedFaceSet_getClassTypeId():
  """SoVRMLIndexedFaceSet_getClassTypeId() -> SoType"""
  return _coin.SoVRMLIndexedFaceSet_getClassTypeId()

def SoVRMLIndexedFaceSet_initClass():
  """SoVRMLIndexedFaceSet_initClass()"""
  return _coin.SoVRMLIndexedFaceSet_initClass()

class SoVRMLVertexLine(SoVRMLGeometry):
    """Proxy of C++ SoVRMLVertexLine class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLVertexLine_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLVertexLine_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLVertexLine_initClass()

    initClass = staticmethod(initClass)
    coord = _swig_property(_coin.SoVRMLVertexLine_coord_get, _coin.SoVRMLVertexLine_coord_set)
    color = _swig_property(_coin.SoVRMLVertexLine_color_get, _coin.SoVRMLVertexLine_color_set)
    colorPerVertex = _swig_property(_coin.SoVRMLVertexLine_colorPerVertex_get, _coin.SoVRMLVertexLine_colorPerVertex_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoVRMLVertexLine_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLVertexLine_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLVertexLine_getBoundingBox(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoVRMLVertexLine_callback(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoVRMLVertexLine_pick(self, *args)

    def notify(self, *args):
        """notify(self, SoNotList list)"""
        return _coin.SoVRMLVertexLine_notify(self, *args)

SoVRMLVertexLine_swigregister = _coin.SoVRMLVertexLine_swigregister
SoVRMLVertexLine_swigregister(SoVRMLVertexLine)

def SoVRMLVertexLine_getClassTypeId():
  """SoVRMLVertexLine_getClassTypeId() -> SoType"""
  return _coin.SoVRMLVertexLine_getClassTypeId()

def SoVRMLVertexLine_initClass():
  """SoVRMLVertexLine_initClass()"""
  return _coin.SoVRMLVertexLine_initClass()

class SoVRMLIndexedLine(SoVRMLVertexLine):
    """Proxy of C++ SoVRMLIndexedLine class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLIndexedLine_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLIndexedLine_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLIndexedLine_initClass()

    initClass = staticmethod(initClass)
    coordIndex = _swig_property(_coin.SoVRMLIndexedLine_coordIndex_get, _coin.SoVRMLIndexedLine_coordIndex_set)
    colorIndex = _swig_property(_coin.SoVRMLIndexedLine_colorIndex_get, _coin.SoVRMLIndexedLine_colorIndex_set)
SoVRMLIndexedLine_swigregister = _coin.SoVRMLIndexedLine_swigregister
SoVRMLIndexedLine_swigregister(SoVRMLIndexedLine)

def SoVRMLIndexedLine_getClassTypeId():
  """SoVRMLIndexedLine_getClassTypeId() -> SoType"""
  return _coin.SoVRMLIndexedLine_getClassTypeId()

def SoVRMLIndexedLine_initClass():
  """SoVRMLIndexedLine_initClass()"""
  return _coin.SoVRMLIndexedLine_initClass()

class SoVRMLIndexedLineSet(SoVRMLIndexedLine):
    """Proxy of C++ SoVRMLIndexedLineSet class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLIndexedLineSet_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLIndexedLineSet_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLIndexedLineSet_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLIndexedLineSet"""
        this = _coin.new_SoVRMLIndexedLineSet()
        try: self.this.append(this)
        except: self.this = this
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLIndexedLineSet_GLRender(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLIndexedLineSet_getPrimitiveCount(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLIndexedLineSet_getBoundingBox(self, *args)

SoVRMLIndexedLineSet_swigregister = _coin.SoVRMLIndexedLineSet_swigregister
SoVRMLIndexedLineSet_swigregister(SoVRMLIndexedLineSet)

def SoVRMLIndexedLineSet_getClassTypeId():
  """SoVRMLIndexedLineSet_getClassTypeId() -> SoType"""
  return _coin.SoVRMLIndexedLineSet_getClassTypeId()

def SoVRMLIndexedLineSet_initClass():
  """SoVRMLIndexedLineSet_initClass()"""
  return _coin.SoVRMLIndexedLineSet_initClass()

class SoVRMLInline(SoNode):
    """Proxy of C++ SoVRMLInline class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLInline_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLInline_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLInline_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLInline"""
        this = _coin.new_SoVRMLInline()
        try: self.this.append(this)
        except: self.this = this
    NEVER = _coin.SoVRMLInline_NEVER
    UNTIL_LOADED = _coin.SoVRMLInline_UNTIL_LOADED
    ALWAYS = _coin.SoVRMLInline_ALWAYS
    bboxCenter = _swig_property(_coin.SoVRMLInline_bboxCenter_get, _coin.SoVRMLInline_bboxCenter_set)
    bboxSize = _swig_property(_coin.SoVRMLInline_bboxSize_get, _coin.SoVRMLInline_bboxSize_set)
    url = _swig_property(_coin.SoVRMLInline_url_get, _coin.SoVRMLInline_url_set)
    def setFullURLName(self, *args):
        """setFullURLName(self, SbString url)"""
        return _coin.SoVRMLInline_setFullURLName(self, *args)

    def getFullURLName(self):
        """getFullURLName(self) -> SbString"""
        return _coin.SoVRMLInline_getFullURLName(self)

    def copyChildren(self):
        """copyChildren(self) -> SoGroup"""
        return _coin.SoVRMLInline_copyChildren(self)

    def requestURLData(self):
        """requestURLData(self)"""
        return _coin.SoVRMLInline_requestURLData(self)

    def isURLDataRequested(self):
        """isURLDataRequested(self) -> SbBool"""
        return _coin.SoVRMLInline_isURLDataRequested(self)

    def isURLDataHere(self):
        """isURLDataHere(self) -> SbBool"""
        return _coin.SoVRMLInline_isURLDataHere(self)

    def cancelURLDataRequest(self):
        """cancelURLDataRequest(self)"""
        return _coin.SoVRMLInline_cancelURLDataRequest(self)

    def setChildData(self, *args):
        """setChildData(self, SoNode urlData)"""
        return _coin.SoVRMLInline_setChildData(self, *args)

    def getChildData(self):
        """getChildData(self) -> SoNode"""
        return _coin.SoVRMLInline_getChildData(self)

    def setFetchURLCallBack(*args):
        """setFetchURLCallBack(SoVRMLInlineFetchURLCB f, void closure)"""
        return _coin.SoVRMLInline_setFetchURLCallBack(*args)

    setFetchURLCallBack = staticmethod(setFetchURLCallBack)
    def setBoundingBoxVisibility(*args):
        """setBoundingBoxVisibility(BboxVisibility b)"""
        return _coin.SoVRMLInline_setBoundingBoxVisibility(*args)

    setBoundingBoxVisibility = staticmethod(setBoundingBoxVisibility)
    def getBoundingBoxVisibility():
        """getBoundingBoxVisibility() -> BboxVisibility"""
        return _coin.SoVRMLInline_getBoundingBoxVisibility()

    getBoundingBoxVisibility = staticmethod(getBoundingBoxVisibility)
    def setBoundingBoxColor(*args):
        """setBoundingBoxColor(SbColor color)"""
        return _coin.SoVRMLInline_setBoundingBoxColor(*args)

    setBoundingBoxColor = staticmethod(setBoundingBoxColor)
    def getBoundingBoxColor():
        """getBoundingBoxColor() -> SbColor"""
        return _coin.SoVRMLInline_getBoundingBoxColor()

    getBoundingBoxColor = staticmethod(getBoundingBoxColor)
    def setReadAsSoFile(*args):
        """setReadAsSoFile(SbBool enable)"""
        return _coin.SoVRMLInline_setReadAsSoFile(*args)

    setReadAsSoFile = staticmethod(setReadAsSoFile)
    def getReadAsSoFile():
        """getReadAsSoFile() -> SbBool"""
        return _coin.SoVRMLInline_getReadAsSoFile()

    getReadAsSoFile = staticmethod(getReadAsSoFile)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoVRMLInline_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoVRMLInline_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLInline_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLInline_getBoundingBox(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoVRMLInline_getMatrix(self, *args)

    def handleEvent(self, *args):
        """handleEvent(self, SoHandleEventAction action)"""
        return _coin.SoVRMLInline_handleEvent(self, *args)

    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoVRMLInline_search(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoVRMLInline_pick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLInline_getPrimitiveCount(self, *args)

    def getChildren(self):
        """getChildren(self) -> SoChildList"""
        return _coin.SoVRMLInline_getChildren(self)

SoVRMLInline_swigregister = _coin.SoVRMLInline_swigregister
SoVRMLInline_swigregister(SoVRMLInline)

def SoVRMLInline_getClassTypeId():
  """SoVRMLInline_getClassTypeId() -> SoType"""
  return _coin.SoVRMLInline_getClassTypeId()

def SoVRMLInline_initClass():
  """SoVRMLInline_initClass()"""
  return _coin.SoVRMLInline_initClass()

def SoVRMLInline_setFetchURLCallBack(*args):
  """SoVRMLInline_setFetchURLCallBack(SoVRMLInlineFetchURLCB f, void closure)"""
  return _coin.SoVRMLInline_setFetchURLCallBack(*args)

def SoVRMLInline_setBoundingBoxVisibility(*args):
  """SoVRMLInline_setBoundingBoxVisibility(BboxVisibility b)"""
  return _coin.SoVRMLInline_setBoundingBoxVisibility(*args)

def SoVRMLInline_getBoundingBoxVisibility():
  """SoVRMLInline_getBoundingBoxVisibility() -> BboxVisibility"""
  return _coin.SoVRMLInline_getBoundingBoxVisibility()

def SoVRMLInline_setBoundingBoxColor(*args):
  """SoVRMLInline_setBoundingBoxColor(SbColor color)"""
  return _coin.SoVRMLInline_setBoundingBoxColor(*args)

def SoVRMLInline_getBoundingBoxColor():
  """SoVRMLInline_getBoundingBoxColor() -> SbColor"""
  return _coin.SoVRMLInline_getBoundingBoxColor()

def SoVRMLInline_setReadAsSoFile(*args):
  """SoVRMLInline_setReadAsSoFile(SbBool enable)"""
  return _coin.SoVRMLInline_setReadAsSoFile(*args)

def SoVRMLInline_getReadAsSoFile():
  """SoVRMLInline_getReadAsSoFile() -> SbBool"""
  return _coin.SoVRMLInline_getReadAsSoFile()

class SoVRMLLOD(SoGroup):
    """Proxy of C++ SoVRMLLOD class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLLOD_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLLOD_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLLOD_initClass()

    initClass = staticmethod(initClass)
    def __init__(self, *args): 
        """
        __init__(self) -> SoVRMLLOD
        __init__(self, int levels) -> SoVRMLLOD
        """
        this = _coin.new_SoVRMLLOD(*args)
        try: self.this.append(this)
        except: self.this = this
    range = _swig_property(_coin.SoVRMLLOD_range_get, _coin.SoVRMLLOD_range_set)
    center = _swig_property(_coin.SoVRMLLOD_center_get, _coin.SoVRMLLOD_center_set)
    level = _swig_property(_coin.SoVRMLLOD_level_get, _coin.SoVRMLLOD_level_set)
    def affectsState(self):
        """affectsState(self) -> SbBool"""
        return _coin.SoVRMLLOD_affectsState(self)

    def addLevel(self, *args):
        """addLevel(self, SoNode level)"""
        return _coin.SoVRMLLOD_addLevel(self, *args)

    def insertLevel(self, *args):
        """insertLevel(self, SoNode level, int idx)"""
        return _coin.SoVRMLLOD_insertLevel(self, *args)

    def getLevel(self, *args):
        """getLevel(self, int idx) -> SoNode"""
        return _coin.SoVRMLLOD_getLevel(self, *args)

    def findLevel(self, *args):
        """findLevel(self, SoNode level) -> int"""
        return _coin.SoVRMLLOD_findLevel(self, *args)

    def getNumLevels(self):
        """getNumLevels(self) -> int"""
        return _coin.SoVRMLLOD_getNumLevels(self)

    def removeLevel(self, *args):
        """
        removeLevel(self, int idx)
        removeLevel(self, SoNode level)
        """
        return _coin.SoVRMLLOD_removeLevel(self, *args)

    def removeAllLevels(self):
        """removeAllLevels(self)"""
        return _coin.SoVRMLLOD_removeAllLevels(self)

    def replaceLevel(self, *args):
        """
        replaceLevel(self, int idx, SoNode level)
        replaceLevel(self, SoNode old, SoNode level)
        """
        return _coin.SoVRMLLOD_replaceLevel(self, *args)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoVRMLLOD_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoVRMLLOD_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLLOD_GLRender(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoVRMLLOD_rayPick(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLLOD_getBoundingBox(self, *args)

    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoVRMLLOD_search(self, *args)

    def write(self, *args):
        """write(self, SoWriteAction action)"""
        return _coin.SoVRMLLOD_write(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLLOD_getPrimitiveCount(self, *args)

    def audioRender(self, *args):
        """audioRender(self, SoAudioRenderAction action)"""
        return _coin.SoVRMLLOD_audioRender(self, *args)

    def GLRenderBelowPath(self, *args):
        """GLRenderBelowPath(self, SoGLRenderAction action)"""
        return _coin.SoVRMLLOD_GLRenderBelowPath(self, *args)

    def GLRenderInPath(self, *args):
        """GLRenderInPath(self, SoGLRenderAction action)"""
        return _coin.SoVRMLLOD_GLRenderInPath(self, *args)

    def GLRenderOffPath(self, *args):
        """GLRenderOffPath(self, SoGLRenderAction action)"""
        return _coin.SoVRMLLOD_GLRenderOffPath(self, *args)

    def addChild(self, *args):
        """addChild(self, SoNode child)"""
        return _coin.SoVRMLLOD_addChild(self, *args)

    def insertChild(self, *args):
        """insertChild(self, SoNode child, int idx)"""
        return _coin.SoVRMLLOD_insertChild(self, *args)

    def getChild(self, *args):
        """getChild(self, int idx) -> SoNode"""
        return _coin.SoVRMLLOD_getChild(self, *args)

    def findChild(self, *args):
        """findChild(self, SoNode child) -> int"""
        return _coin.SoVRMLLOD_findChild(self, *args)

    def getNumChildren(self):
        """getNumChildren(self) -> int"""
        return _coin.SoVRMLLOD_getNumChildren(self)

    def removeChild(self, *args):
        """
        removeChild(self, int idx)
        removeChild(self, SoNode child)
        """
        return _coin.SoVRMLLOD_removeChild(self, *args)

    def removeAllChildren(self):
        """removeAllChildren(self)"""
        return _coin.SoVRMLLOD_removeAllChildren(self)

    def replaceChild(self, *args):
        """
        replaceChild(self, int idx, SoNode child)
        replaceChild(self, SoNode old, SoNode child)
        """
        return _coin.SoVRMLLOD_replaceChild(self, *args)

    def getChildren(self):
        """getChildren(self) -> SoChildList"""
        return _coin.SoVRMLLOD_getChildren(self)

SoVRMLLOD_swigregister = _coin.SoVRMLLOD_swigregister
SoVRMLLOD_swigregister(SoVRMLLOD)

def SoVRMLLOD_getClassTypeId():
  """SoVRMLLOD_getClassTypeId() -> SoType"""
  return _coin.SoVRMLLOD_getClassTypeId()

def SoVRMLLOD_initClass():
  """SoVRMLLOD_initClass()"""
  return _coin.SoVRMLLOD_initClass()

class SoVRMLMaterial(SoNode):
    """Proxy of C++ SoVRMLMaterial class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLMaterial_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLMaterial_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLMaterial_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLMaterial"""
        this = _coin.new_SoVRMLMaterial()
        try: self.this.append(this)
        except: self.this = this
    diffuseColor = _swig_property(_coin.SoVRMLMaterial_diffuseColor_get, _coin.SoVRMLMaterial_diffuseColor_set)
    ambientIntensity = _swig_property(_coin.SoVRMLMaterial_ambientIntensity_get, _coin.SoVRMLMaterial_ambientIntensity_set)
    specularColor = _swig_property(_coin.SoVRMLMaterial_specularColor_get, _coin.SoVRMLMaterial_specularColor_set)
    emissiveColor = _swig_property(_coin.SoVRMLMaterial_emissiveColor_get, _coin.SoVRMLMaterial_emissiveColor_set)
    shininess = _swig_property(_coin.SoVRMLMaterial_shininess_get, _coin.SoVRMLMaterial_shininess_set)
    transparency = _swig_property(_coin.SoVRMLMaterial_transparency_get, _coin.SoVRMLMaterial_transparency_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoVRMLMaterial_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLMaterial_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoVRMLMaterial_callback(self, *args)

SoVRMLMaterial_swigregister = _coin.SoVRMLMaterial_swigregister
SoVRMLMaterial_swigregister(SoVRMLMaterial)

def SoVRMLMaterial_getClassTypeId():
  """SoVRMLMaterial_getClassTypeId() -> SoType"""
  return _coin.SoVRMLMaterial_getClassTypeId()

def SoVRMLMaterial_initClass():
  """SoVRMLMaterial_initClass()"""
  return _coin.SoVRMLMaterial_initClass()

class SoVRMLMovieTexture(SoVRMLTexture):
    """Proxy of C++ SoVRMLMovieTexture class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLMovieTexture_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLMovieTexture_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLMovieTexture_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLMovieTexture"""
        this = _coin.new_SoVRMLMovieTexture()
        try: self.this.append(this)
        except: self.this = this
    loop = _swig_property(_coin.SoVRMLMovieTexture_loop_get, _coin.SoVRMLMovieTexture_loop_set)
    speed = _swig_property(_coin.SoVRMLMovieTexture_speed_get, _coin.SoVRMLMovieTexture_speed_set)
    startTime = _swig_property(_coin.SoVRMLMovieTexture_startTime_get, _coin.SoVRMLMovieTexture_startTime_set)
    stopTime = _swig_property(_coin.SoVRMLMovieTexture_stopTime_get, _coin.SoVRMLMovieTexture_stopTime_set)
    pauseTime = _swig_property(_coin.SoVRMLMovieTexture_pauseTime_get, _coin.SoVRMLMovieTexture_pauseTime_set)
    resumeTime = _swig_property(_coin.SoVRMLMovieTexture_resumeTime_get, _coin.SoVRMLMovieTexture_resumeTime_set)
    url = _swig_property(_coin.SoVRMLMovieTexture_url_get, _coin.SoVRMLMovieTexture_url_set)
    duration_changed = _swig_property(_coin.SoVRMLMovieTexture_duration_changed_get, _coin.SoVRMLMovieTexture_duration_changed_set)
    isActive = _swig_property(_coin.SoVRMLMovieTexture_isActive_get, _coin.SoVRMLMovieTexture_isActive_set)
    alpha = _swig_property(_coin.SoVRMLMovieTexture_alpha_get, _coin.SoVRMLMovieTexture_alpha_set)
    model = _swig_property(_coin.SoVRMLMovieTexture_model_get, _coin.SoVRMLMovieTexture_model_set)
    blendColor = _swig_property(_coin.SoVRMLMovieTexture_blendColor_get, _coin.SoVRMLMovieTexture_blendColor_set)
    scaleTexCoord = _swig_property(_coin.SoVRMLMovieTexture_scaleTexCoord_get, _coin.SoVRMLMovieTexture_scaleTexCoord_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLMovieTexture_GLRender(self, *args)

SoVRMLMovieTexture_swigregister = _coin.SoVRMLMovieTexture_swigregister
SoVRMLMovieTexture_swigregister(SoVRMLMovieTexture)

def SoVRMLMovieTexture_getClassTypeId():
  """SoVRMLMovieTexture_getClassTypeId() -> SoType"""
  return _coin.SoVRMLMovieTexture_getClassTypeId()

def SoVRMLMovieTexture_initClass():
  """SoVRMLMovieTexture_initClass()"""
  return _coin.SoVRMLMovieTexture_initClass()

class SoVRMLNavigationInfo(SoNode):
    """Proxy of C++ SoVRMLNavigationInfo class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLNavigationInfo_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLNavigationInfo_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLNavigationInfo_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLNavigationInfo"""
        this = _coin.new_SoVRMLNavigationInfo()
        try: self.this.append(this)
        except: self.this = this
    type = _swig_property(_coin.SoVRMLNavigationInfo_type_get, _coin.SoVRMLNavigationInfo_type_set)
    speed = _swig_property(_coin.SoVRMLNavigationInfo_speed_get, _coin.SoVRMLNavigationInfo_speed_set)
    avatarSize = _swig_property(_coin.SoVRMLNavigationInfo_avatarSize_get, _coin.SoVRMLNavigationInfo_avatarSize_set)
    visibilityLimit = _swig_property(_coin.SoVRMLNavigationInfo_visibilityLimit_get, _coin.SoVRMLNavigationInfo_visibilityLimit_set)
    headlight = _swig_property(_coin.SoVRMLNavigationInfo_headlight_get, _coin.SoVRMLNavigationInfo_headlight_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLNavigationInfo_GLRender(self, *args)

SoVRMLNavigationInfo_swigregister = _coin.SoVRMLNavigationInfo_swigregister
SoVRMLNavigationInfo_swigregister(SoVRMLNavigationInfo)

def SoVRMLNavigationInfo_getClassTypeId():
  """SoVRMLNavigationInfo_getClassTypeId() -> SoType"""
  return _coin.SoVRMLNavigationInfo_getClassTypeId()

def SoVRMLNavigationInfo_initClass():
  """SoVRMLNavigationInfo_initClass()"""
  return _coin.SoVRMLNavigationInfo_initClass()

class SoVRMLNormal(SoNode):
    """Proxy of C++ SoVRMLNormal class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLNormal_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLNormal_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLNormal_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLNormal"""
        this = _coin.new_SoVRMLNormal()
        try: self.this.append(this)
        except: self.this = this
    vector = _swig_property(_coin.SoVRMLNormal_vector_get, _coin.SoVRMLNormal_vector_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoVRMLNormal_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLNormal_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoVRMLNormal_callback(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoVRMLNormal_pick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLNormal_getPrimitiveCount(self, *args)

SoVRMLNormal_swigregister = _coin.SoVRMLNormal_swigregister
SoVRMLNormal_swigregister(SoVRMLNormal)

def SoVRMLNormal_getClassTypeId():
  """SoVRMLNormal_getClassTypeId() -> SoType"""
  return _coin.SoVRMLNormal_getClassTypeId()

def SoVRMLNormal_initClass():
  """SoVRMLNormal_initClass()"""
  return _coin.SoVRMLNormal_initClass()

class SoVRMLNormalInterpolator(SoVRMLInterpolator):
    """Proxy of C++ SoVRMLNormalInterpolator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLNormalInterpolator_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLNormalInterpolator_getTypeId(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoVRMLNormalInterpolator_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoVRMLNormalInterpolator_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoVRMLNormalInterpolator_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLNormalInterpolator"""
        this = _coin.new_SoVRMLNormalInterpolator()
        try: self.this.append(this)
        except: self.this = this
    keyValue = _swig_property(_coin.SoVRMLNormalInterpolator_keyValue_get, _coin.SoVRMLNormalInterpolator_keyValue_set)
    value_changed = _swig_property(_coin.SoVRMLNormalInterpolator_value_changed_get, _coin.SoVRMLNormalInterpolator_value_changed_set)
SoVRMLNormalInterpolator_swigregister = _coin.SoVRMLNormalInterpolator_swigregister
SoVRMLNormalInterpolator_swigregister(SoVRMLNormalInterpolator)

def SoVRMLNormalInterpolator_getClassTypeId():
  """SoVRMLNormalInterpolator_getClassTypeId() -> SoType"""
  return _coin.SoVRMLNormalInterpolator_getClassTypeId()

def SoVRMLNormalInterpolator_createInstance():
  """SoVRMLNormalInterpolator_createInstance() -> void"""
  return _coin.SoVRMLNormalInterpolator_createInstance()

def SoVRMLNormalInterpolator_initClass():
  """SoVRMLNormalInterpolator_initClass()"""
  return _coin.SoVRMLNormalInterpolator_initClass()

class SoVRMLOrientationInterpolator(SoVRMLInterpolator):
    """Proxy of C++ SoVRMLOrientationInterpolator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLOrientationInterpolator_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLOrientationInterpolator_getTypeId(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoVRMLOrientationInterpolator_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoVRMLOrientationInterpolator_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoVRMLOrientationInterpolator_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLOrientationInterpolator"""
        this = _coin.new_SoVRMLOrientationInterpolator()
        try: self.this.append(this)
        except: self.this = this
    keyValue = _swig_property(_coin.SoVRMLOrientationInterpolator_keyValue_get, _coin.SoVRMLOrientationInterpolator_keyValue_set)
    value_changed = _swig_property(_coin.SoVRMLOrientationInterpolator_value_changed_get, _coin.SoVRMLOrientationInterpolator_value_changed_set)
SoVRMLOrientationInterpolator_swigregister = _coin.SoVRMLOrientationInterpolator_swigregister
SoVRMLOrientationInterpolator_swigregister(SoVRMLOrientationInterpolator)

def SoVRMLOrientationInterpolator_getClassTypeId():
  """SoVRMLOrientationInterpolator_getClassTypeId() -> SoType"""
  return _coin.SoVRMLOrientationInterpolator_getClassTypeId()

def SoVRMLOrientationInterpolator_createInstance():
  """SoVRMLOrientationInterpolator_createInstance() -> void"""
  return _coin.SoVRMLOrientationInterpolator_createInstance()

def SoVRMLOrientationInterpolator_initClass():
  """SoVRMLOrientationInterpolator_initClass()"""
  return _coin.SoVRMLOrientationInterpolator_initClass()

class SoVRMLPixelTexture(SoVRMLTexture):
    """Proxy of C++ SoVRMLPixelTexture class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLPixelTexture_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLPixelTexture_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLPixelTexture_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLPixelTexture"""
        this = _coin.new_SoVRMLPixelTexture()
        try: self.this.append(this)
        except: self.this = this
    image = _swig_property(_coin.SoVRMLPixelTexture_image_get, _coin.SoVRMLPixelTexture_image_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoVRMLPixelTexture_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLPixelTexture_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoVRMLPixelTexture_callback(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoVRMLPixelTexture_rayPick(self, *args)

SoVRMLPixelTexture_swigregister = _coin.SoVRMLPixelTexture_swigregister
SoVRMLPixelTexture_swigregister(SoVRMLPixelTexture)

def SoVRMLPixelTexture_getClassTypeId():
  """SoVRMLPixelTexture_getClassTypeId() -> SoType"""
  return _coin.SoVRMLPixelTexture_getClassTypeId()

def SoVRMLPixelTexture_initClass():
  """SoVRMLPixelTexture_initClass()"""
  return _coin.SoVRMLPixelTexture_initClass()

class SoVRMLPlaneSensor(SoVRMLDragSensor):
    """Proxy of C++ SoVRMLPlaneSensor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLPlaneSensor_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLPlaneSensor_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLPlaneSensor_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLPlaneSensor"""
        this = _coin.new_SoVRMLPlaneSensor()
        try: self.this.append(this)
        except: self.this = this
    minPosition = _swig_property(_coin.SoVRMLPlaneSensor_minPosition_get, _coin.SoVRMLPlaneSensor_minPosition_set)
    maxPosition = _swig_property(_coin.SoVRMLPlaneSensor_maxPosition_get, _coin.SoVRMLPlaneSensor_maxPosition_set)
    offset = _swig_property(_coin.SoVRMLPlaneSensor_offset_get, _coin.SoVRMLPlaneSensor_offset_set)
    translation_changed = _swig_property(_coin.SoVRMLPlaneSensor_translation_changed_get, _coin.SoVRMLPlaneSensor_translation_changed_set)
SoVRMLPlaneSensor_swigregister = _coin.SoVRMLPlaneSensor_swigregister
SoVRMLPlaneSensor_swigregister(SoVRMLPlaneSensor)

def SoVRMLPlaneSensor_getClassTypeId():
  """SoVRMLPlaneSensor_getClassTypeId() -> SoType"""
  return _coin.SoVRMLPlaneSensor_getClassTypeId()

def SoVRMLPlaneSensor_initClass():
  """SoVRMLPlaneSensor_initClass()"""
  return _coin.SoVRMLPlaneSensor_initClass()

class SoVRMLPointLight(SoVRMLLight):
    """Proxy of C++ SoVRMLPointLight class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLPointLight_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLPointLight_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLPointLight_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLPointLight"""
        this = _coin.new_SoVRMLPointLight()
        try: self.this.append(this)
        except: self.this = this
    location = _swig_property(_coin.SoVRMLPointLight_location_get, _coin.SoVRMLPointLight_location_set)
    radius = _swig_property(_coin.SoVRMLPointLight_radius_get, _coin.SoVRMLPointLight_radius_set)
    attenuation = _swig_property(_coin.SoVRMLPointLight_attenuation_get, _coin.SoVRMLPointLight_attenuation_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLPointLight_GLRender(self, *args)

SoVRMLPointLight_swigregister = _coin.SoVRMLPointLight_swigregister
SoVRMLPointLight_swigregister(SoVRMLPointLight)

def SoVRMLPointLight_getClassTypeId():
  """SoVRMLPointLight_getClassTypeId() -> SoType"""
  return _coin.SoVRMLPointLight_getClassTypeId()

def SoVRMLPointLight_initClass():
  """SoVRMLPointLight_initClass()"""
  return _coin.SoVRMLPointLight_initClass()

class SoVRMLVertexPoint(SoVRMLGeometry):
    """Proxy of C++ SoVRMLVertexPoint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLVertexPoint_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLVertexPoint_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLVertexPoint_initClass()

    initClass = staticmethod(initClass)
    coord = _swig_property(_coin.SoVRMLVertexPoint_coord_get, _coin.SoVRMLVertexPoint_coord_set)
    color = _swig_property(_coin.SoVRMLVertexPoint_color_get, _coin.SoVRMLVertexPoint_color_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoVRMLVertexPoint_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLVertexPoint_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLVertexPoint_getBoundingBox(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoVRMLVertexPoint_callback(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoVRMLVertexPoint_pick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLVertexPoint_getPrimitiveCount(self, *args)

    def notify(self, *args):
        """notify(self, SoNotList list)"""
        return _coin.SoVRMLVertexPoint_notify(self, *args)

SoVRMLVertexPoint_swigregister = _coin.SoVRMLVertexPoint_swigregister
SoVRMLVertexPoint_swigregister(SoVRMLVertexPoint)

def SoVRMLVertexPoint_getClassTypeId():
  """SoVRMLVertexPoint_getClassTypeId() -> SoType"""
  return _coin.SoVRMLVertexPoint_getClassTypeId()

def SoVRMLVertexPoint_initClass():
  """SoVRMLVertexPoint_initClass()"""
  return _coin.SoVRMLVertexPoint_initClass()

class SoVRMLPointSet(SoVRMLVertexPoint):
    """Proxy of C++ SoVRMLPointSet class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLPointSet_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLPointSet_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLPointSet_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLPointSet"""
        this = _coin.new_SoVRMLPointSet()
        try: self.this.append(this)
        except: self.this = this
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLPointSet_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLPointSet_getBoundingBox(self, *args)

SoVRMLPointSet_swigregister = _coin.SoVRMLPointSet_swigregister
SoVRMLPointSet_swigregister(SoVRMLPointSet)

def SoVRMLPointSet_getClassTypeId():
  """SoVRMLPointSet_getClassTypeId() -> SoType"""
  return _coin.SoVRMLPointSet_getClassTypeId()

def SoVRMLPointSet_initClass():
  """SoVRMLPointSet_initClass()"""
  return _coin.SoVRMLPointSet_initClass()

class SoVRMLPositionInterpolator(SoVRMLInterpolator):
    """Proxy of C++ SoVRMLPositionInterpolator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLPositionInterpolator_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLPositionInterpolator_getTypeId(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoVRMLPositionInterpolator_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoVRMLPositionInterpolator_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoVRMLPositionInterpolator_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLPositionInterpolator"""
        this = _coin.new_SoVRMLPositionInterpolator()
        try: self.this.append(this)
        except: self.this = this
    keyValue = _swig_property(_coin.SoVRMLPositionInterpolator_keyValue_get, _coin.SoVRMLPositionInterpolator_keyValue_set)
    value_changed = _swig_property(_coin.SoVRMLPositionInterpolator_value_changed_get, _coin.SoVRMLPositionInterpolator_value_changed_set)
SoVRMLPositionInterpolator_swigregister = _coin.SoVRMLPositionInterpolator_swigregister
SoVRMLPositionInterpolator_swigregister(SoVRMLPositionInterpolator)

def SoVRMLPositionInterpolator_getClassTypeId():
  """SoVRMLPositionInterpolator_getClassTypeId() -> SoType"""
  return _coin.SoVRMLPositionInterpolator_getClassTypeId()

def SoVRMLPositionInterpolator_createInstance():
  """SoVRMLPositionInterpolator_createInstance() -> void"""
  return _coin.SoVRMLPositionInterpolator_createInstance()

def SoVRMLPositionInterpolator_initClass():
  """SoVRMLPositionInterpolator_initClass()"""
  return _coin.SoVRMLPositionInterpolator_initClass()

class SoVRMLProximitySensor(SoNode):
    """Proxy of C++ SoVRMLProximitySensor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLProximitySensor_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLProximitySensor_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLProximitySensor_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLProximitySensor"""
        this = _coin.new_SoVRMLProximitySensor()
        try: self.this.append(this)
        except: self.this = this
    center = _swig_property(_coin.SoVRMLProximitySensor_center_get, _coin.SoVRMLProximitySensor_center_set)
    size = _swig_property(_coin.SoVRMLProximitySensor_size_get, _coin.SoVRMLProximitySensor_size_set)
    enabled = _swig_property(_coin.SoVRMLProximitySensor_enabled_get, _coin.SoVRMLProximitySensor_enabled_set)
    isActive = _swig_property(_coin.SoVRMLProximitySensor_isActive_get, _coin.SoVRMLProximitySensor_isActive_set)
    position_changed = _swig_property(_coin.SoVRMLProximitySensor_position_changed_get, _coin.SoVRMLProximitySensor_position_changed_set)
    orientation_changed = _swig_property(_coin.SoVRMLProximitySensor_orientation_changed_get, _coin.SoVRMLProximitySensor_orientation_changed_set)
    enterTime = _swig_property(_coin.SoVRMLProximitySensor_enterTime_get, _coin.SoVRMLProximitySensor_enterTime_set)
    exitTime = _swig_property(_coin.SoVRMLProximitySensor_exitTime_get, _coin.SoVRMLProximitySensor_exitTime_set)
    def affectsState(self):
        """affectsState(self) -> SbBool"""
        return _coin.SoVRMLProximitySensor_affectsState(self)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoVRMLProximitySensor_doAction(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLProximitySensor_GLRender(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoVRMLProximitySensor_callback(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoVRMLProximitySensor_rayPick(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLProximitySensor_getBoundingBox(self, *args)

SoVRMLProximitySensor_swigregister = _coin.SoVRMLProximitySensor_swigregister
SoVRMLProximitySensor_swigregister(SoVRMLProximitySensor)

def SoVRMLProximitySensor_getClassTypeId():
  """SoVRMLProximitySensor_getClassTypeId() -> SoType"""
  return _coin.SoVRMLProximitySensor_getClassTypeId()

def SoVRMLProximitySensor_initClass():
  """SoVRMLProximitySensor_initClass()"""
  return _coin.SoVRMLProximitySensor_initClass()

class SoVRMLScalarInterpolator(SoVRMLInterpolator):
    """Proxy of C++ SoVRMLScalarInterpolator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLScalarInterpolator_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLScalarInterpolator_getTypeId(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoVRMLScalarInterpolator_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoVRMLScalarInterpolator_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoVRMLScalarInterpolator_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLScalarInterpolator"""
        this = _coin.new_SoVRMLScalarInterpolator()
        try: self.this.append(this)
        except: self.this = this
    keyValue = _swig_property(_coin.SoVRMLScalarInterpolator_keyValue_get, _coin.SoVRMLScalarInterpolator_keyValue_set)
    value_changed = _swig_property(_coin.SoVRMLScalarInterpolator_value_changed_get, _coin.SoVRMLScalarInterpolator_value_changed_set)
SoVRMLScalarInterpolator_swigregister = _coin.SoVRMLScalarInterpolator_swigregister
SoVRMLScalarInterpolator_swigregister(SoVRMLScalarInterpolator)

def SoVRMLScalarInterpolator_getClassTypeId():
  """SoVRMLScalarInterpolator_getClassTypeId() -> SoType"""
  return _coin.SoVRMLScalarInterpolator_getClassTypeId()

def SoVRMLScalarInterpolator_createInstance():
  """SoVRMLScalarInterpolator_createInstance() -> void"""
  return _coin.SoVRMLScalarInterpolator_createInstance()

def SoVRMLScalarInterpolator_initClass():
  """SoVRMLScalarInterpolator_initClass()"""
  return _coin.SoVRMLScalarInterpolator_initClass()

class SoVRMLScript(SoNode):
    """Proxy of C++ SoVRMLScript class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def initClass():
        """initClass()"""
        return _coin.SoVRMLScript_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLScript"""
        this = _coin.new_SoVRMLScript()
        try: self.this.append(this)
        except: self.this = this
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLScript_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLScript_getTypeId(self)

    url = _swig_property(_coin.SoVRMLScript_url_get, _coin.SoVRMLScript_url_set)
    directOutput = _swig_property(_coin.SoVRMLScript_directOutput_get, _coin.SoVRMLScript_directOutput_set)
    mustEvaluate = _swig_property(_coin.SoVRMLScript_mustEvaluate_get, _coin.SoVRMLScript_mustEvaluate_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoVRMLScript_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoVRMLScript_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLScript_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLScript_getBoundingBox(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoVRMLScript_pick(self, *args)

    def handleEvent(self, *args):
        """handleEvent(self, SoHandleEventAction action)"""
        return _coin.SoVRMLScript_handleEvent(self, *args)

    def write(self, *args):
        """write(self, SoWriteAction action)"""
        return _coin.SoVRMLScript_write(self, *args)

    def setScriptEvaluateCB(*args):
        """setScriptEvaluateCB(SoVRMLScriptEvaluateCB cb, void closure)"""
        return _coin.SoVRMLScript_setScriptEvaluateCB(*args)

    setScriptEvaluateCB = staticmethod(setScriptEvaluateCB)
SoVRMLScript_swigregister = _coin.SoVRMLScript_swigregister
SoVRMLScript_swigregister(SoVRMLScript)

def SoVRMLScript_initClass():
  """SoVRMLScript_initClass()"""
  return _coin.SoVRMLScript_initClass()

def SoVRMLScript_getClassTypeId():
  """SoVRMLScript_getClassTypeId() -> SoType"""
  return _coin.SoVRMLScript_getClassTypeId()

def SoVRMLScript_setScriptEvaluateCB(*args):
  """SoVRMLScript_setScriptEvaluateCB(SoVRMLScriptEvaluateCB cb, void closure)"""
  return _coin.SoVRMLScript_setScriptEvaluateCB(*args)

class SoVRMLShape(SoNode):
    """Proxy of C++ SoVRMLShape class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLShape_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLShape_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLShape_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLShape"""
        this = _coin.new_SoVRMLShape()
        try: self.this.append(this)
        except: self.this = this
    OFF = _coin.SoVRMLShape_OFF
    ON = _coin.SoVRMLShape_ON
    AUTO = _coin.SoVRMLShape_AUTO
    appearance = _swig_property(_coin.SoVRMLShape_appearance_get, _coin.SoVRMLShape_appearance_set)
    geometry = _swig_property(_coin.SoVRMLShape_geometry_get, _coin.SoVRMLShape_geometry_set)
    renderCaching = _swig_property(_coin.SoVRMLShape_renderCaching_get, _coin.SoVRMLShape_renderCaching_set)
    boundingBoxCaching = _swig_property(_coin.SoVRMLShape_boundingBoxCaching_get, _coin.SoVRMLShape_boundingBoxCaching_set)
    def setNumRenderCaches(*args):
        """setNumRenderCaches(int num)"""
        return _coin.SoVRMLShape_setNumRenderCaches(*args)

    setNumRenderCaches = staticmethod(setNumRenderCaches)
    def getNumRenderCaches():
        """getNumRenderCaches() -> int"""
        return _coin.SoVRMLShape_getNumRenderCaches()

    getNumRenderCaches = staticmethod(getNumRenderCaches)
    def affectsState(self):
        """affectsState(self) -> SbBool"""
        return _coin.SoVRMLShape_affectsState(self)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoVRMLShape_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoVRMLShape_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLShape_GLRender(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLShape_getBoundingBox(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoVRMLShape_rayPick(self, *args)

    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoVRMLShape_search(self, *args)

    def write(self, *args):
        """write(self, SoWriteAction action)"""
        return _coin.SoVRMLShape_write(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLShape_getPrimitiveCount(self, *args)

    def getChildren(self):
        """getChildren(self) -> SoChildList"""
        return _coin.SoVRMLShape_getChildren(self)

    def notify(self, *args):
        """notify(self, SoNotList list)"""
        return _coin.SoVRMLShape_notify(self, *args)

    def copyContents(self, *args):
        """copyContents(self, SoFieldContainer srcFrom, SbBool copyConn)"""
        return _coin.SoVRMLShape_copyContents(self, *args)

SoVRMLShape_swigregister = _coin.SoVRMLShape_swigregister
SoVRMLShape_swigregister(SoVRMLShape)

def SoVRMLShape_getClassTypeId():
  """SoVRMLShape_getClassTypeId() -> SoType"""
  return _coin.SoVRMLShape_getClassTypeId()

def SoVRMLShape_initClass():
  """SoVRMLShape_initClass()"""
  return _coin.SoVRMLShape_initClass()

def SoVRMLShape_setNumRenderCaches(*args):
  """SoVRMLShape_setNumRenderCaches(int num)"""
  return _coin.SoVRMLShape_setNumRenderCaches(*args)

def SoVRMLShape_getNumRenderCaches():
  """SoVRMLShape_getNumRenderCaches() -> int"""
  return _coin.SoVRMLShape_getNumRenderCaches()

class SoVRMLSound(SoNode):
    """Proxy of C++ SoVRMLSound class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLSound_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLSound_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLSound_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLSound"""
        this = _coin.new_SoVRMLSound()
        try: self.this.append(this)
        except: self.this = this
    source = _swig_property(_coin.SoVRMLSound_source_get, _coin.SoVRMLSound_source_set)
    intensity = _swig_property(_coin.SoVRMLSound_intensity_get, _coin.SoVRMLSound_intensity_set)
    priority = _swig_property(_coin.SoVRMLSound_priority_get, _coin.SoVRMLSound_priority_set)
    location = _swig_property(_coin.SoVRMLSound_location_get, _coin.SoVRMLSound_location_set)
    direction = _swig_property(_coin.SoVRMLSound_direction_get, _coin.SoVRMLSound_direction_set)
    minFront = _swig_property(_coin.SoVRMLSound_minFront_get, _coin.SoVRMLSound_minFront_set)
    maxFront = _swig_property(_coin.SoVRMLSound_maxFront_get, _coin.SoVRMLSound_maxFront_set)
    minBack = _swig_property(_coin.SoVRMLSound_minBack_get, _coin.SoVRMLSound_minBack_set)
    maxBack = _swig_property(_coin.SoVRMLSound_maxBack_get, _coin.SoVRMLSound_maxBack_set)
    spatialize = _swig_property(_coin.SoVRMLSound_spatialize_get, _coin.SoVRMLSound_spatialize_set)
    dopplerFactor = _swig_property(_coin.SoVRMLSound_dopplerFactor_get, _coin.SoVRMLSound_dopplerFactor_set)
    dopplerVelocity = _swig_property(_coin.SoVRMLSound_dopplerVelocity_get, _coin.SoVRMLSound_dopplerVelocity_set)
    def setDopplerVelocity(self, *args):
        """setDopplerVelocity(self, float velocity)"""
        return _coin.SoVRMLSound_setDopplerVelocity(self, *args)

    def getDopplerVelocity(self):
        """getDopplerVelocity(self) -> float"""
        return _coin.SoVRMLSound_getDopplerVelocity(self)

    def setDopplerFactor(self, *args):
        """setDopplerFactor(self, float factor)"""
        return _coin.SoVRMLSound_setDopplerFactor(self, *args)

    def getDopplerFactor(self):
        """getDopplerFactor(self) -> float"""
        return _coin.SoVRMLSound_getDopplerFactor(self)

    def startPlaying(self, *args):
        """startPlaying(self, SoPath path, void userdataptr)"""
        return _coin.SoVRMLSound_startPlaying(self, *args)

    def stopPlaying(self, *args):
        """stopPlaying(self, SoPath path, void userdataptr)"""
        return _coin.SoVRMLSound_stopPlaying(self, *args)

    def setDefaultBufferingProperties(*args):
        """setDefaultBufferingProperties(int bufferLength, int numBuffers, SbTime sleepTime)"""
        return _coin.SoVRMLSound_setDefaultBufferingProperties(*args)

    setDefaultBufferingProperties = staticmethod(setDefaultBufferingProperties)
    def setBufferingProperties(self, *args):
        """setBufferingProperties(self, int bufferLength, int numBuffers, SbTime sleepTime)"""
        return _coin.SoVRMLSound_setBufferingProperties(self, *args)

    def getBufferingProperties(self, *args):
        """getBufferingProperties(self, int bufferLength, int numBuffers, SbTime sleepTime)"""
        return _coin.SoVRMLSound_getBufferingProperties(self, *args)

    def audioRender(self, *args):
        """audioRender(self, SoAudioRenderAction action)"""
        return _coin.SoVRMLSound_audioRender(self, *args)

SoVRMLSound_swigregister = _coin.SoVRMLSound_swigregister
SoVRMLSound_swigregister(SoVRMLSound)

def SoVRMLSound_getClassTypeId():
  """SoVRMLSound_getClassTypeId() -> SoType"""
  return _coin.SoVRMLSound_getClassTypeId()

def SoVRMLSound_initClass():
  """SoVRMLSound_initClass()"""
  return _coin.SoVRMLSound_initClass()

def SoVRMLSound_setDefaultBufferingProperties(*args):
  """SoVRMLSound_setDefaultBufferingProperties(int bufferLength, int numBuffers, SbTime sleepTime)"""
  return _coin.SoVRMLSound_setDefaultBufferingProperties(*args)

class SoVRMLSphere(SoVRMLGeometry):
    """Proxy of C++ SoVRMLSphere class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLSphere_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLSphere_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLSphere_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLSphere"""
        this = _coin.new_SoVRMLSphere()
        try: self.this.append(this)
        except: self.this = this
    radius = _swig_property(_coin.SoVRMLSphere_radius_get, _coin.SoVRMLSphere_radius_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLSphere_GLRender(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoVRMLSphere_rayPick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLSphere_getPrimitiveCount(self, *args)

SoVRMLSphere_swigregister = _coin.SoVRMLSphere_swigregister
SoVRMLSphere_swigregister(SoVRMLSphere)

def SoVRMLSphere_getClassTypeId():
  """SoVRMLSphere_getClassTypeId() -> SoType"""
  return _coin.SoVRMLSphere_getClassTypeId()

def SoVRMLSphere_initClass():
  """SoVRMLSphere_initClass()"""
  return _coin.SoVRMLSphere_initClass()

class SoVRMLSphereSensor(SoVRMLDragSensor):
    """Proxy of C++ SoVRMLSphereSensor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLSphereSensor_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLSphereSensor_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLSphereSensor_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLSphereSensor"""
        this = _coin.new_SoVRMLSphereSensor()
        try: self.this.append(this)
        except: self.this = this
    offset = _swig_property(_coin.SoVRMLSphereSensor_offset_get, _coin.SoVRMLSphereSensor_offset_set)
    rotation_changed = _swig_property(_coin.SoVRMLSphereSensor_rotation_changed_get, _coin.SoVRMLSphereSensor_rotation_changed_set)
SoVRMLSphereSensor_swigregister = _coin.SoVRMLSphereSensor_swigregister
SoVRMLSphereSensor_swigregister(SoVRMLSphereSensor)

def SoVRMLSphereSensor_getClassTypeId():
  """SoVRMLSphereSensor_getClassTypeId() -> SoType"""
  return _coin.SoVRMLSphereSensor_getClassTypeId()

def SoVRMLSphereSensor_initClass():
  """SoVRMLSphereSensor_initClass()"""
  return _coin.SoVRMLSphereSensor_initClass()

class SoVRMLSpotLight(SoVRMLLight):
    """Proxy of C++ SoVRMLSpotLight class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLSpotLight_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLSpotLight_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLSpotLight_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLSpotLight"""
        this = _coin.new_SoVRMLSpotLight()
        try: self.this.append(this)
        except: self.this = this
    location = _swig_property(_coin.SoVRMLSpotLight_location_get, _coin.SoVRMLSpotLight_location_set)
    direction = _swig_property(_coin.SoVRMLSpotLight_direction_get, _coin.SoVRMLSpotLight_direction_set)
    beamWidth = _swig_property(_coin.SoVRMLSpotLight_beamWidth_get, _coin.SoVRMLSpotLight_beamWidth_set)
    cutOffAngle = _swig_property(_coin.SoVRMLSpotLight_cutOffAngle_get, _coin.SoVRMLSpotLight_cutOffAngle_set)
    radius = _swig_property(_coin.SoVRMLSpotLight_radius_get, _coin.SoVRMLSpotLight_radius_set)
    attenuation = _swig_property(_coin.SoVRMLSpotLight_attenuation_get, _coin.SoVRMLSpotLight_attenuation_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLSpotLight_GLRender(self, *args)

SoVRMLSpotLight_swigregister = _coin.SoVRMLSpotLight_swigregister
SoVRMLSpotLight_swigregister(SoVRMLSpotLight)

def SoVRMLSpotLight_getClassTypeId():
  """SoVRMLSpotLight_getClassTypeId() -> SoType"""
  return _coin.SoVRMLSpotLight_getClassTypeId()

def SoVRMLSpotLight_initClass():
  """SoVRMLSpotLight_initClass()"""
  return _coin.SoVRMLSpotLight_initClass()

class SoVRMLSwitch(SoGroup):
    """Proxy of C++ SoVRMLSwitch class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLSwitch_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLSwitch_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLSwitch_initClass()

    initClass = staticmethod(initClass)
    def __init__(self, *args): 
        """
        __init__(self) -> SoVRMLSwitch
        __init__(self, int choices) -> SoVRMLSwitch
        """
        this = _coin.new_SoVRMLSwitch(*args)
        try: self.this.append(this)
        except: self.this = this
    choice = _swig_property(_coin.SoVRMLSwitch_choice_get, _coin.SoVRMLSwitch_choice_set)
    whichChoice = _swig_property(_coin.SoVRMLSwitch_whichChoice_get, _coin.SoVRMLSwitch_whichChoice_set)
    def affectsState(self):
        """affectsState(self) -> SbBool"""
        return _coin.SoVRMLSwitch_affectsState(self)

    def addChoice(self, *args):
        """addChoice(self, SoNode choice)"""
        return _coin.SoVRMLSwitch_addChoice(self, *args)

    def insertChoice(self, *args):
        """insertChoice(self, SoNode choice, int idx)"""
        return _coin.SoVRMLSwitch_insertChoice(self, *args)

    def getChoice(self, *args):
        """getChoice(self, int idx) -> SoNode"""
        return _coin.SoVRMLSwitch_getChoice(self, *args)

    def findChoice(self, *args):
        """findChoice(self, SoNode choice) -> int"""
        return _coin.SoVRMLSwitch_findChoice(self, *args)

    def getNumChoices(self):
        """getNumChoices(self) -> int"""
        return _coin.SoVRMLSwitch_getNumChoices(self)

    def removeChoice(self, *args):
        """
        removeChoice(self, int idx)
        removeChoice(self, SoNode node)
        """
        return _coin.SoVRMLSwitch_removeChoice(self, *args)

    def removeAllChoices(self):
        """removeAllChoices(self)"""
        return _coin.SoVRMLSwitch_removeAllChoices(self)

    def replaceChoice(self, *args):
        """
        replaceChoice(self, int idx, SoNode choice)
        replaceChoice(self, SoNode old, SoNode choice)
        """
        return _coin.SoVRMLSwitch_replaceChoice(self, *args)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoVRMLSwitch_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoVRMLSwitch_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLSwitch_GLRender(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoVRMLSwitch_pick(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLSwitch_getBoundingBox(self, *args)

    def handleEvent(self, *args):
        """handleEvent(self, SoHandleEventAction action)"""
        return _coin.SoVRMLSwitch_handleEvent(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoVRMLSwitch_getMatrix(self, *args)

    def search(self, *args):
        """search(self, SoSearchAction action)"""
        return _coin.SoVRMLSwitch_search(self, *args)

    def write(self, *args):
        """write(self, SoWriteAction action)"""
        return _coin.SoVRMLSwitch_write(self, *args)

    def audioRender(self, *args):
        """audioRender(self, SoAudioRenderAction action)"""
        return _coin.SoVRMLSwitch_audioRender(self, *args)

    def addChild(self, *args):
        """addChild(self, SoNode child)"""
        return _coin.SoVRMLSwitch_addChild(self, *args)

    def insertChild(self, *args):
        """insertChild(self, SoNode child, int idx)"""
        return _coin.SoVRMLSwitch_insertChild(self, *args)

    def getChild(self, *args):
        """getChild(self, int idx) -> SoNode"""
        return _coin.SoVRMLSwitch_getChild(self, *args)

    def findChild(self, *args):
        """findChild(self, SoNode child) -> int"""
        return _coin.SoVRMLSwitch_findChild(self, *args)

    def getNumChildren(self):
        """getNumChildren(self) -> int"""
        return _coin.SoVRMLSwitch_getNumChildren(self)

    def removeChild(self, *args):
        """
        removeChild(self, int idx)
        removeChild(self, SoNode child)
        """
        return _coin.SoVRMLSwitch_removeChild(self, *args)

    def removeAllChildren(self):
        """removeAllChildren(self)"""
        return _coin.SoVRMLSwitch_removeAllChildren(self)

    def replaceChild(self, *args):
        """
        replaceChild(self, int idx, SoNode node)
        replaceChild(self, SoNode old, SoNode node)
        """
        return _coin.SoVRMLSwitch_replaceChild(self, *args)

    def getChildren(self):
        """getChildren(self) -> SoChildList"""
        return _coin.SoVRMLSwitch_getChildren(self)

SoVRMLSwitch_swigregister = _coin.SoVRMLSwitch_swigregister
SoVRMLSwitch_swigregister(SoVRMLSwitch)

def SoVRMLSwitch_getClassTypeId():
  """SoVRMLSwitch_getClassTypeId() -> SoType"""
  return _coin.SoVRMLSwitch_getClassTypeId()

def SoVRMLSwitch_initClass():
  """SoVRMLSwitch_initClass()"""
  return _coin.SoVRMLSwitch_initClass()

class SoVRMLText(SoVRMLGeometry):
    """Proxy of C++ SoVRMLText class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLText_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLText_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLText_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLText"""
        this = _coin.new_SoVRMLText()
        try: self.this.append(this)
        except: self.this = this
    string = _swig_property(_coin.SoVRMLText_string_get, _coin.SoVRMLText_string_set)
    fontStyle = _swig_property(_coin.SoVRMLText_fontStyle_get, _coin.SoVRMLText_fontStyle_set)
    maxExtent = _swig_property(_coin.SoVRMLText_maxExtent_get, _coin.SoVRMLText_maxExtent_set)
    length = _swig_property(_coin.SoVRMLText_length_get, _coin.SoVRMLText_length_set)
    BEGIN = _coin.SoVRMLText_BEGIN
    END = _coin.SoVRMLText_END
    MIDDLE = _coin.SoVRMLText_MIDDLE
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLText_GLRender(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLText_getPrimitiveCount(self, *args)

    def notify(self, *args):
        """notify(self, SoNotList list)"""
        return _coin.SoVRMLText_notify(self, *args)

    def getChildren(self):
        """getChildren(self) -> SoChildList"""
        return _coin.SoVRMLText_getChildren(self)

SoVRMLText_swigregister = _coin.SoVRMLText_swigregister
SoVRMLText_swigregister(SoVRMLText)

def SoVRMLText_getClassTypeId():
  """SoVRMLText_getClassTypeId() -> SoType"""
  return _coin.SoVRMLText_getClassTypeId()

def SoVRMLText_initClass():
  """SoVRMLText_initClass()"""
  return _coin.SoVRMLText_initClass()

class SoVRMLTextureCoordinate(SoNode):
    """Proxy of C++ SoVRMLTextureCoordinate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLTextureCoordinate_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLTextureCoordinate_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLTextureCoordinate_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLTextureCoordinate"""
        this = _coin.new_SoVRMLTextureCoordinate()
        try: self.this.append(this)
        except: self.this = this
    point = _swig_property(_coin.SoVRMLTextureCoordinate_point_get, _coin.SoVRMLTextureCoordinate_point_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoVRMLTextureCoordinate_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoVRMLTextureCoordinate_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLTextureCoordinate_GLRender(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoVRMLTextureCoordinate_pick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLTextureCoordinate_getPrimitiveCount(self, *args)

SoVRMLTextureCoordinate_swigregister = _coin.SoVRMLTextureCoordinate_swigregister
SoVRMLTextureCoordinate_swigregister(SoVRMLTextureCoordinate)

def SoVRMLTextureCoordinate_getClassTypeId():
  """SoVRMLTextureCoordinate_getClassTypeId() -> SoType"""
  return _coin.SoVRMLTextureCoordinate_getClassTypeId()

def SoVRMLTextureCoordinate_initClass():
  """SoVRMLTextureCoordinate_initClass()"""
  return _coin.SoVRMLTextureCoordinate_initClass()

class SoVRMLTextureTransform(SoNode):
    """Proxy of C++ SoVRMLTextureTransform class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLTextureTransform_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLTextureTransform_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLTextureTransform_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLTextureTransform"""
        this = _coin.new_SoVRMLTextureTransform()
        try: self.this.append(this)
        except: self.this = this
    translation = _swig_property(_coin.SoVRMLTextureTransform_translation_get, _coin.SoVRMLTextureTransform_translation_set)
    rotation = _swig_property(_coin.SoVRMLTextureTransform_rotation_get, _coin.SoVRMLTextureTransform_rotation_set)
    scale = _swig_property(_coin.SoVRMLTextureTransform_scale_get, _coin.SoVRMLTextureTransform_scale_set)
    center = _swig_property(_coin.SoVRMLTextureTransform_center_get, _coin.SoVRMLTextureTransform_center_set)
    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoVRMLTextureTransform_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoVRMLTextureTransform_callback(self, *args)

    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLTextureTransform_GLRender(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoVRMLTextureTransform_getMatrix(self, *args)

    def pick(self, *args):
        """pick(self, SoPickAction action)"""
        return _coin.SoVRMLTextureTransform_pick(self, *args)

SoVRMLTextureTransform_swigregister = _coin.SoVRMLTextureTransform_swigregister
SoVRMLTextureTransform_swigregister(SoVRMLTextureTransform)

def SoVRMLTextureTransform_getClassTypeId():
  """SoVRMLTextureTransform_getClassTypeId() -> SoType"""
  return _coin.SoVRMLTextureTransform_getClassTypeId()

def SoVRMLTextureTransform_initClass():
  """SoVRMLTextureTransform_initClass()"""
  return _coin.SoVRMLTextureTransform_initClass()

class SoVRMLTimeSensor(SoNodeEngine):
    """Proxy of C++ SoVRMLTimeSensor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLTimeSensor_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLTimeSensor_getTypeId(self)

    def getOutputData(self):
        """getOutputData(self) -> SoEngineOutputData"""
        return _coin.SoVRMLTimeSensor_getOutputData(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoVRMLTimeSensor_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoVRMLTimeSensor_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLTimeSensor"""
        this = _coin.new_SoVRMLTimeSensor()
        try: self.this.append(this)
        except: self.this = this
    cycleInterval = _swig_property(_coin.SoVRMLTimeSensor_cycleInterval_get, _coin.SoVRMLTimeSensor_cycleInterval_set)
    enabled = _swig_property(_coin.SoVRMLTimeSensor_enabled_get, _coin.SoVRMLTimeSensor_enabled_set)
    loop = _swig_property(_coin.SoVRMLTimeSensor_loop_get, _coin.SoVRMLTimeSensor_loop_set)
    startTime = _swig_property(_coin.SoVRMLTimeSensor_startTime_get, _coin.SoVRMLTimeSensor_startTime_set)
    stopTime = _swig_property(_coin.SoVRMLTimeSensor_stopTime_get, _coin.SoVRMLTimeSensor_stopTime_set)
    def notify(self, *args):
        """notify(self, SoNotList list)"""
        return _coin.SoVRMLTimeSensor_notify(self, *args)

    def handleEvent(self, *args):
        """handleEvent(self, SoHandleEventAction action)"""
        return _coin.SoVRMLTimeSensor_handleEvent(self, *args)

    def write(self, *args):
        """write(self, SoWriteAction action)"""
        return _coin.SoVRMLTimeSensor_write(self, *args)

    cycleTime = _swig_property(_coin.SoVRMLTimeSensor_cycleTime_get, _coin.SoVRMLTimeSensor_cycleTime_set)
    fraction_changed = _swig_property(_coin.SoVRMLTimeSensor_fraction_changed_get, _coin.SoVRMLTimeSensor_fraction_changed_set)
    isActive = _swig_property(_coin.SoVRMLTimeSensor_isActive_get, _coin.SoVRMLTimeSensor_isActive_set)
    time = _swig_property(_coin.SoVRMLTimeSensor_time_get, _coin.SoVRMLTimeSensor_time_set)
SoVRMLTimeSensor_swigregister = _coin.SoVRMLTimeSensor_swigregister
SoVRMLTimeSensor_swigregister(SoVRMLTimeSensor)

def SoVRMLTimeSensor_getClassTypeId():
  """SoVRMLTimeSensor_getClassTypeId() -> SoType"""
  return _coin.SoVRMLTimeSensor_getClassTypeId()

def SoVRMLTimeSensor_createInstance():
  """SoVRMLTimeSensor_createInstance() -> void"""
  return _coin.SoVRMLTimeSensor_createInstance()

def SoVRMLTimeSensor_initClass():
  """SoVRMLTimeSensor_initClass()"""
  return _coin.SoVRMLTimeSensor_initClass()

class SoVRMLTouchSensor(SoNode):
    """Proxy of C++ SoVRMLTouchSensor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLTouchSensor_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLTouchSensor_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLTouchSensor_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLTouchSensor"""
        this = _coin.new_SoVRMLTouchSensor()
        try: self.this.append(this)
        except: self.this = this
    enabled = _swig_property(_coin.SoVRMLTouchSensor_enabled_get, _coin.SoVRMLTouchSensor_enabled_set)
    hitNormal_changed = _swig_property(_coin.SoVRMLTouchSensor_hitNormal_changed_get, _coin.SoVRMLTouchSensor_hitNormal_changed_set)
    hitPoint_changed = _swig_property(_coin.SoVRMLTouchSensor_hitPoint_changed_get, _coin.SoVRMLTouchSensor_hitPoint_changed_set)
    hitTexCoord_changed = _swig_property(_coin.SoVRMLTouchSensor_hitTexCoord_changed_get, _coin.SoVRMLTouchSensor_hitTexCoord_changed_set)
    isActive = _swig_property(_coin.SoVRMLTouchSensor_isActive_get, _coin.SoVRMLTouchSensor_isActive_set)
    isOver = _swig_property(_coin.SoVRMLTouchSensor_isOver_get, _coin.SoVRMLTouchSensor_isOver_set)
    touchTime = _swig_property(_coin.SoVRMLTouchSensor_touchTime_get, _coin.SoVRMLTouchSensor_touchTime_set)
    def affectsState(self):
        """affectsState(self) -> SbBool"""
        return _coin.SoVRMLTouchSensor_affectsState(self)

    def handleEvent(self, *args):
        """handleEvent(self, SoHandleEventAction action)"""
        return _coin.SoVRMLTouchSensor_handleEvent(self, *args)

SoVRMLTouchSensor_swigregister = _coin.SoVRMLTouchSensor_swigregister
SoVRMLTouchSensor_swigregister(SoVRMLTouchSensor)

def SoVRMLTouchSensor_getClassTypeId():
  """SoVRMLTouchSensor_getClassTypeId() -> SoType"""
  return _coin.SoVRMLTouchSensor_getClassTypeId()

def SoVRMLTouchSensor_initClass():
  """SoVRMLTouchSensor_initClass()"""
  return _coin.SoVRMLTouchSensor_initClass()

class SoVRMLTransform(SoVRMLGroup):
    """Proxy of C++ SoVRMLTransform class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLTransform_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLTransform_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLTransform_initClass()

    initClass = staticmethod(initClass)
    def __init__(self, *args): 
        """
        __init__(self) -> SoVRMLTransform
        __init__(self, int children) -> SoVRMLTransform
        """
        this = _coin.new_SoVRMLTransform(*args)
        try: self.this.append(this)
        except: self.this = this
    translation = _swig_property(_coin.SoVRMLTransform_translation_get, _coin.SoVRMLTransform_translation_set)
    rotation = _swig_property(_coin.SoVRMLTransform_rotation_get, _coin.SoVRMLTransform_rotation_set)
    scale = _swig_property(_coin.SoVRMLTransform_scale_get, _coin.SoVRMLTransform_scale_set)
    scaleOrientation = _swig_property(_coin.SoVRMLTransform_scaleOrientation_get, _coin.SoVRMLTransform_scaleOrientation_set)
    center = _swig_property(_coin.SoVRMLTransform_center_get, _coin.SoVRMLTransform_center_set)
    def pointAt(self, *args):
        """pointAt(self, SbVec3f srcFrom, SbVec3f destTo)"""
        return _coin.SoVRMLTransform_pointAt(self, *args)

    def getScaleSpaceMatrix(self, *args):
        """getScaleSpaceMatrix(self, SbMatrix inverse)"""
        return _coin.SoVRMLTransform_getScaleSpaceMatrix(self, *args)

    def getRotationSpaceMatrix(self, *args):
        """getRotationSpaceMatrix(self, SbMatrix inverse)"""
        return _coin.SoVRMLTransform_getRotationSpaceMatrix(self, *args)

    def getTranslationSpaceMatrix(self, *args):
        """getTranslationSpaceMatrix(self, SbMatrix inverse)"""
        return _coin.SoVRMLTransform_getTranslationSpaceMatrix(self, *args)

    def multLeft(self):
        """multLeft(self)"""
        return _coin.SoVRMLTransform_multLeft(self)

    def multRight(self):
        """multRight(self)"""
        return _coin.SoVRMLTransform_multRight(self)

    def combineLeft(self, *args):
        """combineLeft(self, SoVRMLTransform leftnode)"""
        return _coin.SoVRMLTransform_combineLeft(self, *args)

    def combineRight(self, *args):
        """combineRight(self, SoVRMLTransform rightnode)"""
        return _coin.SoVRMLTransform_combineRight(self, *args)

    def setMatrix(self):
        """setMatrix(self)"""
        return _coin.SoVRMLTransform_setMatrix(self)

    def recenter(self, *args):
        """recenter(self, SbVec3f newcenter)"""
        return _coin.SoVRMLTransform_recenter(self, *args)

    def doAction(self, *args):
        """doAction(self, SoAction action)"""
        return _coin.SoVRMLTransform_doAction(self, *args)

    def callback(self, *args):
        """callback(self, SoCallbackAction action)"""
        return _coin.SoVRMLTransform_callback(self, *args)

    def getBoundingBox(self, *args):
        """getBoundingBox(self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLTransform_getBoundingBox(self, *args)

    def getMatrix(self, *args):
        """getMatrix(self, SoGetMatrixAction action)"""
        return _coin.SoVRMLTransform_getMatrix(self, *args)

    def rayPick(self, *args):
        """rayPick(self, SoRayPickAction action)"""
        return _coin.SoVRMLTransform_rayPick(self, *args)

    def getPrimitiveCount(self, *args):
        """getPrimitiveCount(self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLTransform_getPrimitiveCount(self, *args)

    def audioRender(self, *args):
        """audioRender(self, SoAudioRenderAction action)"""
        return _coin.SoVRMLTransform_audioRender(self, *args)

    def GLRenderBelowPath(self, *args):
        """GLRenderBelowPath(self, SoGLRenderAction action)"""
        return _coin.SoVRMLTransform_GLRenderBelowPath(self, *args)

    def GLRenderInPath(self, *args):
        """GLRenderInPath(self, SoGLRenderAction action)"""
        return _coin.SoVRMLTransform_GLRenderInPath(self, *args)

    def notify(self, *args):
        """notify(self, SoNotList list)"""
        return _coin.SoVRMLTransform_notify(self, *args)

SoVRMLTransform_swigregister = _coin.SoVRMLTransform_swigregister
SoVRMLTransform_swigregister(SoVRMLTransform)

def SoVRMLTransform_getClassTypeId():
  """SoVRMLTransform_getClassTypeId() -> SoType"""
  return _coin.SoVRMLTransform_getClassTypeId()

def SoVRMLTransform_initClass():
  """SoVRMLTransform_initClass()"""
  return _coin.SoVRMLTransform_initClass()

class SoVRMLViewpoint(SoNode):
    """Proxy of C++ SoVRMLViewpoint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLViewpoint_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLViewpoint_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLViewpoint_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLViewpoint"""
        this = _coin.new_SoVRMLViewpoint()
        try: self.this.append(this)
        except: self.this = this
    position = _swig_property(_coin.SoVRMLViewpoint_position_get, _coin.SoVRMLViewpoint_position_set)
    orientation = _swig_property(_coin.SoVRMLViewpoint_orientation_get, _coin.SoVRMLViewpoint_orientation_set)
    fieldOfView = _swig_property(_coin.SoVRMLViewpoint_fieldOfView_get, _coin.SoVRMLViewpoint_fieldOfView_set)
    description = _swig_property(_coin.SoVRMLViewpoint_description_get, _coin.SoVRMLViewpoint_description_set)
    jump = _swig_property(_coin.SoVRMLViewpoint_jump_get, _coin.SoVRMLViewpoint_jump_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLViewpoint_GLRender(self, *args)

SoVRMLViewpoint_swigregister = _coin.SoVRMLViewpoint_swigregister
SoVRMLViewpoint_swigregister(SoVRMLViewpoint)

def SoVRMLViewpoint_getClassTypeId():
  """SoVRMLViewpoint_getClassTypeId() -> SoType"""
  return _coin.SoVRMLViewpoint_getClassTypeId()

def SoVRMLViewpoint_initClass():
  """SoVRMLViewpoint_initClass()"""
  return _coin.SoVRMLViewpoint_initClass()

class SoVRMLVisibilitySensor(SoNode):
    """Proxy of C++ SoVRMLVisibilitySensor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLVisibilitySensor_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLVisibilitySensor_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLVisibilitySensor_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLVisibilitySensor"""
        this = _coin.new_SoVRMLVisibilitySensor()
        try: self.this.append(this)
        except: self.this = this
    center = _swig_property(_coin.SoVRMLVisibilitySensor_center_get, _coin.SoVRMLVisibilitySensor_center_set)
    size = _swig_property(_coin.SoVRMLVisibilitySensor_size_get, _coin.SoVRMLVisibilitySensor_size_set)
    enabled = _swig_property(_coin.SoVRMLVisibilitySensor_enabled_get, _coin.SoVRMLVisibilitySensor_enabled_set)
    enterTime = _swig_property(_coin.SoVRMLVisibilitySensor_enterTime_get, _coin.SoVRMLVisibilitySensor_enterTime_set)
    exitTime = _swig_property(_coin.SoVRMLVisibilitySensor_exitTime_get, _coin.SoVRMLVisibilitySensor_exitTime_set)
    isActive = _swig_property(_coin.SoVRMLVisibilitySensor_isActive_get, _coin.SoVRMLVisibilitySensor_isActive_set)
    def GLRender(self, *args):
        """GLRender(self, SoGLRenderAction action)"""
        return _coin.SoVRMLVisibilitySensor_GLRender(self, *args)

SoVRMLVisibilitySensor_swigregister = _coin.SoVRMLVisibilitySensor_swigregister
SoVRMLVisibilitySensor_swigregister(SoVRMLVisibilitySensor)

def SoVRMLVisibilitySensor_getClassTypeId():
  """SoVRMLVisibilitySensor_getClassTypeId() -> SoType"""
  return _coin.SoVRMLVisibilitySensor_getClassTypeId()

def SoVRMLVisibilitySensor_initClass():
  """SoVRMLVisibilitySensor_initClass()"""
  return _coin.SoVRMLVisibilitySensor_initClass()

class SoVRMLWorldInfo(SoNode):
    """Proxy of C++ SoVRMLWorldInfo class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoVRMLWorldInfo_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoVRMLWorldInfo_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.SoVRMLWorldInfo_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoVRMLWorldInfo"""
        this = _coin.new_SoVRMLWorldInfo()
        try: self.this.append(this)
        except: self.this = this
    title = _swig_property(_coin.SoVRMLWorldInfo_title_get, _coin.SoVRMLWorldInfo_title_set)
    info = _swig_property(_coin.SoVRMLWorldInfo_info_get, _coin.SoVRMLWorldInfo_info_set)
SoVRMLWorldInfo_swigregister = _coin.SoVRMLWorldInfo_swigregister
SoVRMLWorldInfo_swigregister(SoVRMLWorldInfo)

def SoVRMLWorldInfo_getClassTypeId():
  """SoVRMLWorldInfo_getClassTypeId() -> SoType"""
  return _coin.SoVRMLWorldInfo_getClassTypeId()

def SoVRMLWorldInfo_initClass():
  """SoVRMLWorldInfo_initClass()"""
  return _coin.SoVRMLWorldInfo_initClass()

class SoEventManager(object):
    """Proxy of C++ SoEventManager class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoEventManager"""
        this = _coin.new_SoEventManager()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoEventManager
    __del__ = lambda self : None;
    NO_NAVIGATION = _coin.SoEventManager_NO_NAVIGATION
    JUST_NAVIGATION = _coin.SoEventManager_JUST_NAVIGATION
    MIXED_NAVIGATION = _coin.SoEventManager_MIXED_NAVIGATION
    def setSceneGraph(self, *args):
        """setSceneGraph(self, SoNode sceneroot)"""
        return _coin.SoEventManager_setSceneGraph(self, *args)

    def getSceneGraph(self):
        """getSceneGraph(self) -> SoNode"""
        return _coin.SoEventManager_getSceneGraph(self)

    def setCamera(self, *args):
        """setCamera(self, SoCamera camera)"""
        return _coin.SoEventManager_setCamera(self, *args)

    def getCamera(self):
        """getCamera(self) -> SoCamera"""
        return _coin.SoEventManager_getCamera(self)

    def processEvent(self, *args):
        """processEvent(self, SoEvent event) -> SbBool"""
        return _coin.SoEventManager_processEvent(self, *args)

    def setNavigationState(self, *args):
        """setNavigationState(self, NavigationState state)"""
        return _coin.SoEventManager_setNavigationState(self, *args)

    def getNavigationState(self):
        """getNavigationState(self) -> NavigationState"""
        return _coin.SoEventManager_getNavigationState(self)

    def getNumSoScXMLStateMachines(self):
        """getNumSoScXMLStateMachines(self) -> int"""
        return _coin.SoEventManager_getNumSoScXMLStateMachines(self)

    def getSoScXMLStateMachine(self, *args):
        """getSoScXMLStateMachine(self, int idx) -> SoScXMLStateMachine"""
        return _coin.SoEventManager_getSoScXMLStateMachine(self, *args)

    def addSoScXMLStateMachine(self, *args):
        """addSoScXMLStateMachine(self, SoScXMLStateMachine sm)"""
        return _coin.SoEventManager_addSoScXMLStateMachine(self, *args)

    def removeSoScXMLStateMachine(self, *args):
        """removeSoScXMLStateMachine(self, SoScXMLStateMachine sm)"""
        return _coin.SoEventManager_removeSoScXMLStateMachine(self, *args)

    def setSize(self, *args):
        """setSize(self, SbVec2s newsize)"""
        return _coin.SoEventManager_setSize(self, *args)

    def setOrigin(self, *args):
        """setOrigin(self, SbVec2s newOrigin)"""
        return _coin.SoEventManager_setOrigin(self, *args)

    def setViewportRegion(self, *args):
        """setViewportRegion(self, SbViewportRegion newregion)"""
        return _coin.SoEventManager_setViewportRegion(self, *args)

    def getViewportRegion(self):
        """getViewportRegion(self) -> SbViewportRegion"""
        return _coin.SoEventManager_getViewportRegion(self)

    def setHandleEventAction(self, *args):
        """setHandleEventAction(self, SoHandleEventAction hea)"""
        return _coin.SoEventManager_setHandleEventAction(self, *args)

    def getHandleEventAction(self):
        """getHandleEventAction(self) -> SoHandleEventAction"""
        return _coin.SoEventManager_getHandleEventAction(self)

SoEventManager_swigregister = _coin.SoEventManager_swigregister
SoEventManager_swigregister(SoEventManager)

class SoRenderManager(object):
    """Proxy of C++ SoRenderManager class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    AS_IS = _coin.SoRenderManager_AS_IS
    WIREFRAME = _coin.SoRenderManager_WIREFRAME
    POINTS = _coin.SoRenderManager_POINTS
    WIREFRAME_OVERLAY = _coin.SoRenderManager_WIREFRAME_OVERLAY
    HIDDEN_LINE = _coin.SoRenderManager_HIDDEN_LINE
    BOUNDING_BOX = _coin.SoRenderManager_BOUNDING_BOX
    MONO = _coin.SoRenderManager_MONO
    ANAGLYPH = _coin.SoRenderManager_ANAGLYPH
    SEPARATE_OUTPUT = _coin.SoRenderManager_SEPARATE_OUTPUT
    QUAD_BUFFER = _coin.SoRenderManager_QUAD_BUFFER
    INTERLEAVED_ROWS = _coin.SoRenderManager_INTERLEAVED_ROWS
    INTERLEAVED_COLUMNS = _coin.SoRenderManager_INTERLEAVED_COLUMNS
    BUFFER_SINGLE = _coin.SoRenderManager_BUFFER_SINGLE
    BUFFER_DOUBLE = _coin.SoRenderManager_BUFFER_DOUBLE
    NO_AUTO_CLIPPING = _coin.SoRenderManager_NO_AUTO_CLIPPING
    FIXED_NEAR_PLANE = _coin.SoRenderManager_FIXED_NEAR_PLANE
    VARIABLE_NEAR_PLANE = _coin.SoRenderManager_VARIABLE_NEAR_PLANE
    def __init__(self): 
        """__init__(self) -> SoRenderManager"""
        this = _coin.new_SoRenderManager()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoRenderManager
    __del__ = lambda self : None;
    def render(self, *args):
        """
        render(self, SbBool clearwindow = 1, SbBool clearzbuffer = 1)
        render(self, SbBool clearwindow = 1)
        render(self)
        render(self, SoGLRenderAction action, SbBool initmatrices = 1, SbBool clearwindow = 1, 
            SbBool clearzbuffer = 1)
        render(self, SoGLRenderAction action, SbBool initmatrices = 1, SbBool clearwindow = 1)
        render(self, SoGLRenderAction action, SbBool initmatrices = 1)
        render(self, SoGLRenderAction action)
        """
        return _coin.SoRenderManager_render(self, *args)

    def addSuperimposition(self, *args):
        """
        addSuperimposition(self, SoNode scene, uint32_t flags = Superimposition::AUTOREDRAW|Superimposition::ZBUFFERON|Superimposition::CLEARZBUFFER) -> Superimposition
        addSuperimposition(self, SoNode scene) -> Superimposition
        """
        return _coin.SoRenderManager_addSuperimposition(self, *args)

    def removeSuperimposition(self, *args):
        """removeSuperimposition(self, Superimposition s)"""
        return _coin.SoRenderManager_removeSuperimposition(self, *args)

    def setSceneGraph(self, *args):
        """setSceneGraph(self, SoNode sceneroot)"""
        return _coin.SoRenderManager_setSceneGraph(self, *args)

    def getSceneGraph(self):
        """getSceneGraph(self) -> SoNode"""
        return _coin.SoRenderManager_getSceneGraph(self)

    def setCamera(self, *args):
        """setCamera(self, SoCamera camera)"""
        return _coin.SoRenderManager_setCamera(self, *args)

    def getCamera(self):
        """getCamera(self) -> SoCamera"""
        return _coin.SoRenderManager_getCamera(self)

    def setAutoClipping(self, *args):
        """setAutoClipping(self, AutoClippingStrategy autoclipping)"""
        return _coin.SoRenderManager_setAutoClipping(self, *args)

    def attachRootSensor(self, *args):
        """attachRootSensor(self, SoNode sceneroot)"""
        return _coin.SoRenderManager_attachRootSensor(self, *args)

    def attachClipSensor(self, *args):
        """attachClipSensor(self, SoNode sceneroot)"""
        return _coin.SoRenderManager_attachClipSensor(self, *args)

    def detachRootSensor(self):
        """detachRootSensor(self)"""
        return _coin.SoRenderManager_detachRootSensor(self)

    def detachClipSensor(self):
        """detachClipSensor(self)"""
        return _coin.SoRenderManager_detachClipSensor(self)

    def getAutoClipping(self):
        """getAutoClipping(self) -> AutoClippingStrategy"""
        return _coin.SoRenderManager_getAutoClipping(self)

    def setNearPlaneValue(self, *args):
        """setNearPlaneValue(self, float value)"""
        return _coin.SoRenderManager_setNearPlaneValue(self, *args)

    def getNearPlaneValue(self):
        """getNearPlaneValue(self) -> float"""
        return _coin.SoRenderManager_getNearPlaneValue(self)

    def setTexturesEnabled(self, *args):
        """setTexturesEnabled(self, SbBool onoff)"""
        return _coin.SoRenderManager_setTexturesEnabled(self, *args)

    def isTexturesEnabled(self):
        """isTexturesEnabled(self) -> SbBool"""
        return _coin.SoRenderManager_isTexturesEnabled(self)

    def setDoubleBuffer(self, *args):
        """setDoubleBuffer(self, SbBool enable)"""
        return _coin.SoRenderManager_setDoubleBuffer(self, *args)

    def isDoubleBuffer(self):
        """isDoubleBuffer(self) -> SbBool"""
        return _coin.SoRenderManager_isDoubleBuffer(self)

    def setRenderMode(self, *args):
        """setRenderMode(self, RenderMode mode)"""
        return _coin.SoRenderManager_setRenderMode(self, *args)

    def getRenderMode(self):
        """getRenderMode(self) -> RenderMode"""
        return _coin.SoRenderManager_getRenderMode(self)

    def setStereoMode(self, *args):
        """setStereoMode(self, StereoMode mode)"""
        return _coin.SoRenderManager_setStereoMode(self, *args)

    def getStereoMode(self):
        """getStereoMode(self) -> StereoMode"""
        return _coin.SoRenderManager_getStereoMode(self)

    def setStereoOffset(self, *args):
        """setStereoOffset(self, float offset)"""
        return _coin.SoRenderManager_setStereoOffset(self, *args)

    def getStereoOffset(self):
        """getStereoOffset(self) -> float"""
        return _coin.SoRenderManager_getStereoOffset(self)

    def isAutoRedraw(self):
        """isAutoRedraw(self) -> SbBool"""
        return _coin.SoRenderManager_isAutoRedraw(self)

    def setRedrawPriority(self, *args):
        """setRedrawPriority(self, uint32_t priority)"""
        return _coin.SoRenderManager_setRedrawPriority(self, *args)

    def getRedrawPriority(self):
        """getRedrawPriority(self) -> uint32_t"""
        return _coin.SoRenderManager_getRedrawPriority(self)

    def nodesensorCB(*args):
        """nodesensorCB(void data, SoSensor arg1)"""
        return _coin.SoRenderManager_nodesensorCB(*args)

    nodesensorCB = staticmethod(nodesensorCB)
    def prerendercb(*args):
        """prerendercb(void userdata, SoGLRenderAction action)"""
        return _coin.SoRenderManager_prerendercb(*args)

    prerendercb = staticmethod(prerendercb)
    def reinitialize(self):
        """reinitialize(self)"""
        return _coin.SoRenderManager_reinitialize(self)

    def scheduleRedraw(self):
        """scheduleRedraw(self)"""
        return _coin.SoRenderManager_scheduleRedraw(self)

    def setWindowSize(self, *args):
        """setWindowSize(self, SbVec2s newsize)"""
        return _coin.SoRenderManager_setWindowSize(self, *args)

    def getWindowSize(self):
        """getWindowSize(self) -> SbVec2s"""
        return _coin.SoRenderManager_getWindowSize(self)

    def setSize(self, *args):
        """setSize(self, SbVec2s newsize)"""
        return _coin.SoRenderManager_setSize(self, *args)

    def getSize(self):
        """getSize(self) -> SbVec2s"""
        return _coin.SoRenderManager_getSize(self)

    def setOrigin(self, *args):
        """setOrigin(self, SbVec2s newOrigin)"""
        return _coin.SoRenderManager_setOrigin(self, *args)

    def getOrigin(self):
        """getOrigin(self) -> SbVec2s"""
        return _coin.SoRenderManager_getOrigin(self)

    def setViewportRegion(self, *args):
        """setViewportRegion(self, SbViewportRegion newRegion)"""
        return _coin.SoRenderManager_setViewportRegion(self, *args)

    def getViewportRegion(self):
        """getViewportRegion(self) -> SbViewportRegion"""
        return _coin.SoRenderManager_getViewportRegion(self)

    def setBackgroundColor(self, *args):
        """setBackgroundColor(self, SbColor4f color)"""
        return _coin.SoRenderManager_setBackgroundColor(self, *args)

    def getBackgroundColor(self):
        """getBackgroundColor(self) -> SbColor4f"""
        return _coin.SoRenderManager_getBackgroundColor(self)

    def setBackgroundIndex(self, *args):
        """setBackgroundIndex(self, int index)"""
        return _coin.SoRenderManager_setBackgroundIndex(self, *args)

    def getBackgroundIndex(self):
        """getBackgroundIndex(self) -> int"""
        return _coin.SoRenderManager_getBackgroundIndex(self)

    def setRGBMode(self, *args):
        """setRGBMode(self, SbBool onOrOff)"""
        return _coin.SoRenderManager_setRGBMode(self, *args)

    def isRGBMode(self):
        """isRGBMode(self) -> SbBool"""
        return _coin.SoRenderManager_isRGBMode(self)

    def activate(self):
        """activate(self)"""
        return _coin.SoRenderManager_activate(self)

    def deactivate(self):
        """deactivate(self)"""
        return _coin.SoRenderManager_deactivate(self)

    def setAntialiasing(self, *args):
        """setAntialiasing(self, SbBool smoothing, int numPasses)"""
        return _coin.SoRenderManager_setAntialiasing(self, *args)

    def getAntialiasing(self, *args):
        """getAntialiasing(self, SbBool smoothing, int numPasses)"""
        return _coin.SoRenderManager_getAntialiasing(self, *args)

    def setGLRenderAction(self, *args):
        """setGLRenderAction(self, SoGLRenderAction action)"""
        return _coin.SoRenderManager_setGLRenderAction(self, *args)

    def getGLRenderAction(self):
        """getGLRenderAction(self) -> SoGLRenderAction"""
        return _coin.SoRenderManager_getGLRenderAction(self)

    def setAudioRenderAction(self, *args):
        """setAudioRenderAction(self, SoAudioRenderAction action)"""
        return _coin.SoRenderManager_setAudioRenderAction(self, *args)

    def getAudioRenderAction(self):
        """getAudioRenderAction(self) -> SoAudioRenderAction"""
        return _coin.SoRenderManager_getAudioRenderAction(self)

    def enableRealTimeUpdate(*args):
        """enableRealTimeUpdate(SbBool flag)"""
        return _coin.SoRenderManager_enableRealTimeUpdate(*args)

    enableRealTimeUpdate = staticmethod(enableRealTimeUpdate)
    def isRealTimeUpdateEnabled():
        """isRealTimeUpdateEnabled() -> SbBool"""
        return _coin.SoRenderManager_isRealTimeUpdateEnabled()

    isRealTimeUpdateEnabled = staticmethod(isRealTimeUpdateEnabled)
    def getDefaultRedrawPriority():
        """getDefaultRedrawPriority() -> uint32_t"""
        return _coin.SoRenderManager_getDefaultRedrawPriority()

    getDefaultRedrawPriority = staticmethod(getDefaultRedrawPriority)
    def setRenderCallback(self, *args):
        """
        setRenderCallback(self, SoRenderManagerRenderCB f, void userData = None)
        setRenderCallback(self, SoRenderManagerRenderCB f)
        setRenderCallback(self, PyObject pyfunc, PyObject userData = None)
        setRenderCallback(self, PyObject pyfunc)
        """
        return _coin.SoRenderManager_setRenderCallback(self, *args)

    def addPreRenderCallback(self, *args):
        """
        addPreRenderCallback(self, SoRenderManagerRenderCB cb, void data)
        addPreRenderCallback(self, PyObject pyfunc, PyObject data)
        """
        return _coin.SoRenderManager_addPreRenderCallback(self, *args)

    def removePreRenderCallback(self, *args):
        """
        removePreRenderCallback(self, SoRenderManagerRenderCB cb, void data)
        removePreRenderCallback(self, PyObject pyfunc, PyObject data)
        """
        return _coin.SoRenderManager_removePreRenderCallback(self, *args)

    def addPostRenderCallback(self, *args):
        """
        addPostRenderCallback(self, SoRenderManagerRenderCB cb, void data)
        addPostRenderCallback(self, PyObject pyfunc, PyObject data)
        """
        return _coin.SoRenderManager_addPostRenderCallback(self, *args)

    def removePostRenderCallback(self, *args):
        """
        removePostRenderCallback(self, SoRenderManagerRenderCB cb, void data)
        removePostRenderCallback(self, PyObject pyfunc, PyObject data)
        """
        return _coin.SoRenderManager_removePostRenderCallback(self, *args)

SoRenderManager_swigregister = _coin.SoRenderManager_swigregister
SoRenderManager_swigregister(SoRenderManager)

def SoRenderManager_nodesensorCB(*args):
  """SoRenderManager_nodesensorCB(void data, SoSensor arg1)"""
  return _coin.SoRenderManager_nodesensorCB(*args)

def SoRenderManager_prerendercb(*args):
  """SoRenderManager_prerendercb(void userdata, SoGLRenderAction action)"""
  return _coin.SoRenderManager_prerendercb(*args)

def SoRenderManager_enableRealTimeUpdate(*args):
  """SoRenderManager_enableRealTimeUpdate(SbBool flag)"""
  return _coin.SoRenderManager_enableRealTimeUpdate(*args)

def SoRenderManager_isRealTimeUpdateEnabled():
  """SoRenderManager_isRealTimeUpdateEnabled() -> SbBool"""
  return _coin.SoRenderManager_isRealTimeUpdateEnabled()

def SoRenderManager_getDefaultRedrawPriority():
  """SoRenderManager_getDefaultRedrawPriority() -> uint32_t"""
  return _coin.SoRenderManager_getDefaultRedrawPriority()

class ScXMLObject(object):
    """Proxy of C++ ScXMLObject class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.ScXMLObject_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.ScXMLObject_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.ScXMLObject_initClass()

    initClass = staticmethod(initClass)
    __swig_destroy__ = _coin.delete_ScXMLObject
    __del__ = lambda self : None;
    def isOfType(self, *args):
        """isOfType(self, SoType type) -> SbBool"""
        return _coin.ScXMLObject_isOfType(self, *args)

    def setXMLAttribute(self, *args):
        """setXMLAttribute(self, char attribute, char value)"""
        return _coin.ScXMLObject_setXMLAttribute(self, *args)

    def getXMLAttribute(self, *args):
        """getXMLAttribute(self, char attribute) -> char"""
        return _coin.ScXMLObject_getXMLAttribute(self, *args)

    def handleXMLAttributes(self):
        """handleXMLAttributes(self) -> SbBool"""
        return _coin.ScXMLObject_handleXMLAttributes(self)

    def setContainer(self, *args):
        """setContainer(self, ScXMLObject container)"""
        return _coin.ScXMLObject_setContainer(self, *args)

    def getContainer(self):
        """getContainer(self) -> ScXMLObject"""
        return _coin.ScXMLObject_getContainer(self)

    def isContainedIn(self, *args):
        """isContainedIn(self, ScXMLObject object) -> SbBool"""
        return _coin.ScXMLObject_isContainedIn(self, *args)

ScXMLObject_swigregister = _coin.ScXMLObject_swigregister
ScXMLObject_swigregister(ScXMLObject)

def ScXMLObject_getClassTypeId():
  """ScXMLObject_getClassTypeId() -> SoType"""
  return _coin.ScXMLObject_getClassTypeId()

def ScXMLObject_initClass():
  """ScXMLObject_initClass()"""
  return _coin.ScXMLObject_initClass()

class ScXMLEvent(ScXMLObject):
    """Proxy of C++ ScXMLEvent class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.ScXMLEvent_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.ScXMLEvent_getTypeId(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.ScXMLEvent_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.ScXMLEvent_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> ScXMLEvent"""
        this = _coin.new_ScXMLEvent()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_ScXMLEvent
    __del__ = lambda self : None;
    def setIdentifier(self, *args):
        """setIdentifier(self, SbName identifier)"""
        return _coin.ScXMLEvent_setIdentifier(self, *args)

    def getIdentifier(self):
        """getIdentifier(self) -> SbName"""
        return _coin.ScXMLEvent_getIdentifier(self)

ScXMLEvent_swigregister = _coin.ScXMLEvent_swigregister
ScXMLEvent_swigregister(ScXMLEvent)

def ScXMLEvent_getClassTypeId():
  """ScXMLEvent_getClassTypeId() -> SoType"""
  return _coin.ScXMLEvent_getClassTypeId()

def ScXMLEvent_createInstance():
  """ScXMLEvent_createInstance() -> void"""
  return _coin.ScXMLEvent_createInstance()

def ScXMLEvent_initClass():
  """ScXMLEvent_initClass()"""
  return _coin.ScXMLEvent_initClass()

SCXML_DEFAULT_NS = _coin.SCXML_DEFAULT_NS
SCXML_COIN_NS = _coin.SCXML_COIN_NS
class ScXML(object):
    """Proxy of C++ ScXML class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def initClasses():
        """initClasses()"""
        return _coin.ScXML_initClasses()

    initClasses = staticmethod(initClasses)
    def readFile(*args):
        """readFile(char filename) -> ScXMLStateMachine"""
        return _coin.ScXML_readFile(*args)

    readFile = staticmethod(readFile)
    def readBuffer(*args):
        """readBuffer(char bufferdata) -> ScXMLStateMachine"""
        return _coin.ScXML_readBuffer(*args)

    readBuffer = staticmethod(readBuffer)
    def __init__(self): 
        """__init__(self) -> ScXML"""
        this = _coin.new_ScXML()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_ScXML
    __del__ = lambda self : None;
ScXML_swigregister = _coin.ScXML_swigregister
ScXML_swigregister(ScXML)

def ScXML_initClasses():
  """ScXML_initClasses()"""
  return _coin.ScXML_initClasses()

def ScXML_readFile(*args):
  """ScXML_readFile(char filename) -> ScXMLStateMachine"""
  return _coin.ScXML_readFile(*args)

def ScXML_readBuffer(*args):
  """ScXML_readBuffer(char bufferdata) -> ScXMLStateMachine"""
  return _coin.ScXML_readBuffer(*args)

class ScXMLInvoke(ScXMLObject):
    """Proxy of C++ ScXMLInvoke class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.ScXMLInvoke_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.ScXMLInvoke_getTypeId(self)

    def initClass():
        """initClass()"""
        return _coin.ScXMLInvoke_initClass()

    initClass = staticmethod(initClass)
    __swig_destroy__ = _coin.delete_ScXMLInvoke
    __del__ = lambda self : None;
    def setTargetTypeAttribute(self, *args):
        """setTargetTypeAttribute(self, char id)"""
        return _coin.ScXMLInvoke_setTargetTypeAttribute(self, *args)

    def getTargetTypeAttribute(self):
        """getTargetTypeAttribute(self) -> char"""
        return _coin.ScXMLInvoke_getTargetTypeAttribute(self)

    def setSrcAttribute(self, *args):
        """setSrcAttribute(self, char id)"""
        return _coin.ScXMLInvoke_setSrcAttribute(self, *args)

    def getSrcAttribute(self):
        """getSrcAttribute(self) -> char"""
        return _coin.ScXMLInvoke_getSrcAttribute(self)

    def setSrcExprAttribute(self, *args):
        """setSrcExprAttribute(self, char id)"""
        return _coin.ScXMLInvoke_setSrcExprAttribute(self, *args)

    def getSrcExprAttribute(self):
        """getSrcExprAttribute(self) -> char"""
        return _coin.ScXMLInvoke_getSrcExprAttribute(self)

    def handleXMLAttributes(self):
        """handleXMLAttributes(self) -> SbBool"""
        return _coin.ScXMLInvoke_handleXMLAttributes(self)

    def invoke(self, *args):
        """invoke(self, ScXMLStateMachine statemachine)"""
        return _coin.ScXMLInvoke_invoke(self, *args)

ScXMLInvoke_swigregister = _coin.ScXMLInvoke_swigregister
ScXMLInvoke_swigregister(ScXMLInvoke)

def ScXMLInvoke_getClassTypeId():
  """ScXMLInvoke_getClassTypeId() -> SoType"""
  return _coin.ScXMLInvoke_getClassTypeId()

def ScXMLInvoke_initClass():
  """ScXMLInvoke_initClass()"""
  return _coin.ScXMLInvoke_initClass()

class ScXMLStateMachine(ScXMLObject):
    """Proxy of C++ ScXMLStateMachine class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.ScXMLStateMachine_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.ScXMLStateMachine_getTypeId(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.ScXMLStateMachine_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.ScXMLStateMachine_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> ScXMLStateMachine"""
        this = _coin.new_ScXMLStateMachine()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_ScXMLStateMachine
    __del__ = lambda self : None;
    def setName(self, *args):
        """setName(self, SbName name)"""
        return _coin.ScXMLStateMachine_setName(self, *args)

    def getName(self):
        """getName(self) -> SbName"""
        return _coin.ScXMLStateMachine_getName(self)

    def setDescription(self, *args):
        """setDescription(self, ScXMLDocument document)"""
        return _coin.ScXMLStateMachine_setDescription(self, *args)

    def getDescription(self):
        """getDescription(self) -> ScXMLDocument"""
        return _coin.ScXMLStateMachine_getDescription(self)

    def initialize(self):
        """initialize(self)"""
        return _coin.ScXMLStateMachine_initialize(self)

    def queueEvent(self, *args):
        """
        queueEvent(self, ScXMLEvent event, SbBool dealloc = 0)
        queueEvent(self, ScXMLEvent event)
        queueEvent(self, SbName eventid)
        """
        return _coin.ScXMLStateMachine_queueEvent(self, *args)

    def processEventQueue(self):
        """processEventQueue(self) -> SbBool"""
        return _coin.ScXMLStateMachine_processEventQueue(self)

    def isActive(self):
        """isActive(self) -> SbBool"""
        return _coin.ScXMLStateMachine_isActive(self)

    def isFinished(self):
        """isFinished(self) -> SbBool"""
        return _coin.ScXMLStateMachine_isFinished(self)

    def getCurrentEvent(self):
        """getCurrentEvent(self) -> ScXMLEvent"""
        return _coin.ScXMLStateMachine_getCurrentEvent(self)

    def getNumActiveStates(self):
        """getNumActiveStates(self) -> int"""
        return _coin.ScXMLStateMachine_getNumActiveStates(self)

    def getActiveState(self, *args):
        """getActiveState(self, int idx) -> ScXMLObject"""
        return _coin.ScXMLStateMachine_getActiveState(self, *args)

    def getState(self, *args):
        """getState(self, char identifier) -> ScXMLObject"""
        return _coin.ScXMLStateMachine_getState(self, *args)

    def addDeleteCallback(self, *args):
        """
        addDeleteCallback(self, ScXMLStateMachineDeleteCB callback, void userdata)
        addDeleteCallback(self, PyObject pyfunc, PyObject userdata)
        """
        return _coin.ScXMLStateMachine_addDeleteCallback(self, *args)

    def removeDeleteCallback(self, *args):
        """
        removeDeleteCallback(self, ScXMLStateMachineDeleteCB callback, void userdata)
        removeDeleteCallback(self, PyObject pyfunc, PyObject userdata)
        """
        return _coin.ScXMLStateMachine_removeDeleteCallback(self, *args)

    def addStateChangeCallback(self, *args):
        """
        addStateChangeCallback(self, ScXMLStateChangeCB callback, void userdata)
        addStateChangeCallback(self, PyObject pyfunc, PyObject userdata)
        """
        return _coin.ScXMLStateMachine_addStateChangeCallback(self, *args)

    def removeStateChangeCallback(self, *args):
        """
        removeStateChangeCallback(self, ScXMLStateChangeCB callback, void userdata)
        removeStateChangeCallback(self, PyObject pyfunc, PyObject userdata)
        """
        return _coin.ScXMLStateMachine_removeStateChangeCallback(self, *args)

ScXMLStateMachine_swigregister = _coin.ScXMLStateMachine_swigregister
ScXMLStateMachine_swigregister(ScXMLStateMachine)

def ScXMLStateMachine_getClassTypeId():
  """ScXMLStateMachine_getClassTypeId() -> SoType"""
  return _coin.ScXMLStateMachine_getClassTypeId()

def ScXMLStateMachine_createInstance():
  """ScXMLStateMachine_createInstance() -> void"""
  return _coin.ScXMLStateMachine_createInstance()

def ScXMLStateMachine_initClass():
  """ScXMLStateMachine_initClass()"""
  return _coin.ScXMLStateMachine_initClass()

class SoScXMLEvent(ScXMLEvent):
    """Proxy of C++ SoScXMLEvent class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoScXMLEvent_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoScXMLEvent_getTypeId(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoScXMLEvent_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoScXMLEvent_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoScXMLEvent"""
        this = _coin.new_SoScXMLEvent()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoScXMLEvent
    __del__ = lambda self : None;
    def setSoEvent(self, *args):
        """setSoEvent(self, SoEvent soevent)"""
        return _coin.SoScXMLEvent_setSoEvent(self, *args)

    def getSoEvent(self):
        """getSoEvent(self) -> SoEvent"""
        return _coin.SoScXMLEvent_getSoEvent(self)

    def setUpIdentifier(self):
        """setUpIdentifier(self)"""
        return _coin.SoScXMLEvent_setUpIdentifier(self)

SoScXMLEvent_swigregister = _coin.SoScXMLEvent_swigregister
SoScXMLEvent_swigregister(SoScXMLEvent)

def SoScXMLEvent_getClassTypeId():
  """SoScXMLEvent_getClassTypeId() -> SoType"""
  return _coin.SoScXMLEvent_getClassTypeId()

def SoScXMLEvent_createInstance():
  """SoScXMLEvent_createInstance() -> void"""
  return _coin.SoScXMLEvent_createInstance()

def SoScXMLEvent_initClass():
  """SoScXMLEvent_initClass()"""
  return _coin.SoScXMLEvent_initClass()

class SoScXMLStateMachine(ScXMLStateMachine):
    """Proxy of C++ SoScXMLStateMachine class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def getClassTypeId():
        """getClassTypeId() -> SoType"""
        return _coin.SoScXMLStateMachine_getClassTypeId()

    getClassTypeId = staticmethod(getClassTypeId)
    def getTypeId(self):
        """getTypeId(self) -> SoType"""
        return _coin.SoScXMLStateMachine_getTypeId(self)

    def createInstance():
        """createInstance() -> void"""
        return _coin.SoScXMLStateMachine_createInstance()

    createInstance = staticmethod(createInstance)
    def initClass():
        """initClass()"""
        return _coin.SoScXMLStateMachine_initClass()

    initClass = staticmethod(initClass)
    def __init__(self): 
        """__init__(self) -> SoScXMLStateMachine"""
        this = _coin.new_SoScXMLStateMachine()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _coin.delete_SoScXMLStateMachine
    __del__ = lambda self : None;
    def setSceneGraphRoot(self, *args):
        """setSceneGraphRoot(self, SoNode root)"""
        return _coin.SoScXMLStateMachine_setSceneGraphRoot(self, *args)

    def getSceneGraphRoot(self):
        """getSceneGraphRoot(self) -> SoNode"""
        return _coin.SoScXMLStateMachine_getSceneGraphRoot(self)

    def setActiveCamera(self, *args):
        """setActiveCamera(self, SoCamera camera)"""
        return _coin.SoScXMLStateMachine_setActiveCamera(self, *args)

    def getActiveCamera(self):
        """getActiveCamera(self) -> SoCamera"""
        return _coin.SoScXMLStateMachine_getActiveCamera(self)

    def setViewportRegion(self, *args):
        """setViewportRegion(self, SbViewportRegion vp)"""
        return _coin.SoScXMLStateMachine_setViewportRegion(self, *args)

    def getViewportRegion(self):
        """getViewportRegion(self) -> SbViewportRegion"""
        return _coin.SoScXMLStateMachine_getViewportRegion(self)

    def preGLRender(self):
        """preGLRender(self)"""
        return _coin.SoScXMLStateMachine_preGLRender(self)

    def postGLRender(self):
        """postGLRender(self)"""
        return _coin.SoScXMLStateMachine_postGLRender(self)

    def processSoEvent(self, *args):
        """processSoEvent(self, SoEvent event) -> SbBool"""
        return _coin.SoScXMLStateMachine_processSoEvent(self, *args)

SoScXMLStateMachine_swigregister = _coin.SoScXMLStateMachine_swigregister
SoScXMLStateMachine_swigregister(SoScXMLStateMachine)

def SoScXMLStateMachine_getClassTypeId():
  """SoScXMLStateMachine_getClassTypeId() -> SoType"""
  return _coin.SoScXMLStateMachine_getClassTypeId()

def SoScXMLStateMachine_createInstance():
  """SoScXMLStateMachine_createInstance() -> void"""
  return _coin.SoScXMLStateMachine_createInstance()

def SoScXMLStateMachine_initClass():
  """SoScXMLStateMachine_initClass()"""
  return _coin.SoScXMLStateMachine_initClass()

for x in locals().values():
  if isinstance(x, type) and issubclass(x, SoFieldContainer):
    for name, thing in x.__dict__.items():
      if isinstance(thing, property):
        delattr(x, name)